When Is Agentic RAG Worth the Cost in Production?
- LAST UPDATED
- 27 min read
Key takeaways
- The extra money buys judgment. In the health plan example, that's the agent noticing a missing therapy record and going back for it before it recommends anything.
- Running every request through the agent costs about three times as much. In the model later in this guide, sending simple questions down a cheaper path cuts that by roughly 40 percent.
- Compliance is settled in the architecture. We'd design permission-aware retrieval, per-hop audit logs, and human sign-off in before the first pilot user logs on.
- The plumbing is mostly solved on AWS. Between Amazon Bedrock Knowledge Bases and Amazon Bedrock AgentCore, you get retrieval, a runtime, tools, identity, and tracing, so what's left for your team is the authority boundary, the evaluation set, and getting source systems ready.
- About 12 weeks to production is realistic for a scoped use case, as long as those three are sorted out in the first two weeks.
Definition
It comes down to what the person asking actually needs. If a nurse at the health plan we use as an example below wants to know what the knee MRI policy says, one document answers it, and enhanced RAG with hybrid search and reranking will find it for a fraction of the price. If she wants to know whether this member's request meets that policy, the answer is spread across eligibility, claims, and the policy itself, and someone has to sign the recommendation. That's the kind of work where an agent that plans its own searches, checks the evidence, and searches again when something's missing earns back what it costs.
A lot of enterprise AI programs are stuck between a working pilot and a system anyone will sign off on. McKinsey's 2026 State of AI survey has the share of $1 billion-plus companies scaling agents in at least one function at 40 percent, up from 27 percent a year earlier. That's real movement, but it means most big companies are still somewhere between the pilot and the payoff.
Throughout this guide we'll come back to a regional health plan with about 600,000 members. Every prior-authorization request that lands there gets checked by a nurse against roughly 400 clinical policy documents, the member's eligibility in the core admin system, past claims, and the provider directory, and the policies are updated monthly. A standard RAG assistant can tell a nurse what the knee MRI policy says, but what the nurses actually want is something that checks whether this particular member's request meets it, shows the evidence, and puts the case in the right queue.
We've been building data and AI systems on AWS since 2008, a lot of them for banks, health plans, payments companies, and SaaS platforms that live under audit. Across that work, retrieval has kept the systems honest about the data and agency has let them finish the job, and in our experience a business owner won't sign off until both have been built for production.
What Is Agentic RAG, and Why Does Production Need Retrieval and Agency Both?
Say the health plan's first pilot was a plain RAG assistant. It did one search, wrote one answer, and the nurses liked it for policy questions. Then they started pasting in real requests, and it would quote the knee MRI policy correctly while saying nothing about whether the member had done the six weeks of physical therapy the policy requires, because that was in the claims system and nobody had asked it to look there. The nurses went back to checking eligibility and claims by hand. Loan exceptions at a bank and renewal-risk reviews at a software company break a plain RAG assistant in the same way.
An agent with no retrieval fails in the opposite direction. It'll plan the whole review without complaint, working from whatever the model picked up in pretraining, and that's how you get an agent quoting a policy version the health plan retired two years ago. Agentic RAG combines the two, with controls around them, so the system reads current data and keeps a record an auditor can follow.
|
Dimension |
Traditional RAG |
Tool-calling agent (no retrieval) |
Agentic RAG |
|---|---|---|---|
|
How it retrieves |
One search, top few chunks |
Only through the occasional API call |
Several planned searches, checked as it goes |
|
Who decides the next step |
The code, because the pipeline is fixed |
The model, and nothing stops it |
The agent, within limits your policy sets |
|
Typical failure |
Misses multi-part questions |
Invented facts and unsafe actions |
Runaway loops and cost if nothing caps it |
|
Audit footprint |
The query and retrieved chunks |
Tool calls only |
Every plan, retrieval hop, and tool call |
|
Relative cost per query |
Lowest |
Moderate |
Highest, which is why routing matters |
|
Best fit |
FAQ, policy lookup, enterprise search |
Narrow, well-defined actions |
Multi-step research, decisions, and governed actions |
How Does Agentic RAG Work Once Real Users Arrive?
When the agent version picked up the same knee MRI request, it started by breaking it into three questions: was the member eligible on the date of service, which version of the imaging policy applied, and did the claims show the physical therapy?
That's query decomposition. It sent the eligibility question to the admin system through a Model Context Protocol (MCP) tool, the policy question to a vector index, the claims question to a SQL tool, and the ordering physician's details to a knowledge graph. The first claims search came back empty, because the therapy had been billed under a different provider.
So the agent rewrote the query and searched again, the same idea researchers describe as Corrective RAG and Self-RAG. With all three answers in hand, it wrote a short recommendation, cited each source, and dropped it in a nurse's queue for her to approve or reject.
Of the four things the agent did there, which were planning, routing, retrieving and checking, and handing off to a nurse, the last is where both the value and the risk are, so in our AI agents work we write it down before any code exists. The document says what the agent can do alone, what needs a person to approve it, and what it isn't allowed to touch. At the health plan, our version of that document would allow drafted approvals, which a nurse then signs, and would rule out the agent denying anything. On bigger programs we sometimes see the job split among specialist agents. One does research, one checks policy, one takes actions, and a supervisor agent hands out the work. That setup is called multi-agent RAG, and while it helps in complex domains, every extra agent adds hops you'll have to trace.

When Does Agentic RAG Earn Its Cost, and When Is Standard RAG Enough?
Most vendor content skips this question, and it's the first one your CFO will ask. The best data we've seen on it comes from a team that put both designs side by side and presented the results at ACL 2026, in a paper titled Is Agentic RAG worth it? Their agentic setups used, on average, 3.3 times as many input tokens, 1.9 times as many output tokens, and 1.5 times as much time as an enhanced RAG pipeline with reranking. Neither design came out ahead overall. The agentic version was better at working out what the user meant and rewriting the query, and the enhanced pipeline was better at ranking documents and routed more reliably when the domain was broad or messy.
That matches what we see in regulated production work. We'd let agency handle the steps that need judgment and keep everything else on the cheaper path. The Retrieval-Agency Fit Matrix below is what we use with leadership teams to make that call in one working session, and it's how we'd frame the agentic RAG vs. RAG decision for any use case.

Five signals that a use case is ready for agentic RAG:
- Users regularly ask questions that span two or more systems of record.
- When you look at today's RAG answers, a fair number get escalated or redone because some piece of context wasn't there.
- Somebody acts on the answer, and there's money attached, whether that's a claim, a credit decision, a refund, or a closed ticket.
- The documents change every week or so, which means one static retrieval goes stale fast.
- You can name the executive who's accountable for what the agent is allowed to do.
If you can't check that last box yet, we'd hold off on the agent and ship enhanced RAG with hybrid search first. Every component carries forward into the agentic version later, so none of the work is wasted.
What Does a Production Agentic RAG Architecture Look Like on AWS?
AWS has closed most of the plumbing gap. If you're starting a new agent today, it goes on Amazon Bedrock AgentCore. AWS renamed the original Amazon Bedrock Agents to Agents Classic and closed it to new customers on July 30, 2026. Existing accounts can keep using it and there's no end-of-life date yet, but if your pilot was built on it, we'd plan the move to AgentCore up front so it doesn't turn into a change order later. The table below maps each layer of an agentic RAG architecture to the AWS services we use and the decision your team still has to make.
|
Layer |
What it does |
AWS options |
Decision you own |
|---|---|---|---|
|
Knowledge ingestion |
Pulls in source content, then parses, chunks, and embeds it |
We'd use the Amazon Bedrock Managed Knowledge Base, which has connectors for Amazon S3, SharePoint, Confluence, Google Drive, and OneDrive, or a customer-managed knowledge base when you index into your own vector store |
Which sources are authoritative, and who owns freshness |
|
Index and vector store |
Holds the embeddings and runs hybrid search |
Managed Knowledge Base looks after storage for you; otherwise we'd pick from Amazon OpenSearch Serverless, Amazon S3 Vectors, Aurora PostgreSQL with pgvector, or Amazon Neptune Analytics for GraphRAG |
Latency target vs. storage cost, and EU data residency |
|
Agent runtime |
Runs the plan, route, retrieve, and verify loop |
AgentCore Runtime with Strands Agents, LangGraph, or another framework |
Maximum steps, timeouts, and the fallback path |
|
Tools |
Exposes APIs and functions to the agent |
AgentCore Gateway, which turns APIs and AWS Lambda functions into MCP tools |
Which actions are read-only and which need approval |
|
Identity and policy |
Passes the user's identity into every retrieval and tool call |
AgentCore Identity works with Amazon Cognito, Okta, or Microsoft Entra ID, and AgentCore Policy enforces Cedar rules at the Gateway |
The entitlement model enforced inside the query |
|
Safety |
Screens prompts and checks that answers are grounded |
Amazon Bedrock Guardrails, with content filters that catch prompt attacks, contextual grounding checks, sensitive-information filters, and Automated Reasoning checks |
Block vs. flag thresholds |
|
Memory |
Keeps session and long-term context |
AgentCore Memory |
Retention rules, and what must be forgotten |
|
Evaluation and observability |
Traces every hop and scores quality |
AgentCore Observability (OpenTelemetry, in Amazon CloudWatch) and AgentCore Evaluations |
Release gates and alert thresholds |
One change from this fall affects the first row. Since September 30, 2026, AWS hasn't allowed new Confluence, SharePoint, Salesforce, or Web Crawler connectors on customer-managed knowledge bases, and it now sends those sources to the Managed Knowledge Base, which looks after vector storage itself. For the health plan, that settles where the SharePoint policy library goes, while claims data stays in its own database behind a SQL tool.
Fraud rings, supply networks, and provider directories are all about relationships, and that's where a knowledge graph next to the vector index pays off, using GraphRAG on Neptune Analytics. We'd still start with hybrid search and only add the graph when the evaluation set shows it's needed.
Managed retrieval service or a custom agent? Here's how we frame the build choice for clients:
|
Option |
Where it fits |
Trade-off |
|---|---|---|
|
Managed agentic retrieval in the Amazon Bedrock Managed Knowledge Base |
Research and Q&A across documents, with the fastest time to value |
Less control over the planning logic, and per-call pricing |
|
Custom agent on AgentCore (Strands or LangGraph), with the knowledge base as a tool |
Workflows that read from and write to systems of record |
More engineering, but full control of routing, policy, and audit |
|
An assistant bolted onto an existing SaaS app |
Light internal search |
Limited auditability, and data may leave your AWS account boundary |
Our guide to running Amazon Bedrock agents in production goes deeper on inference profiles, batch pricing, and why guardrails and authorization solve different problems. For teams building agentic RAG on Amazon Bedrock, we usually end up recommending the custom path as soon as the agent has to touch a system of record, since that's where policy and audit requirements get specific, and the health plan's eligibility lookup is a good example.
How Do You Keep Agentic RAG Compliant With HIPAA, SOC 2, GDPR, and the EU AI Act?
In our experience compliance teams don't object to AI as such. They object to systems that can't show their work, and an agent cuts both ways there, since it takes more steps than a pipeline but every one of them can be logged if you plan for it. IBM's 2026 breach study shows why they're nervous: more than 20 percent of the organizations it surveyed had already had a breach aimed at an AI model or application.
Ask us for one control and we'd pick permission-aware retrieval. The nurse's entitlements decide what the agent is allowed to pull before the query runs, rather than someone trimming the results afterward. Filtering after the fact is how a well-meaning agent ends up summarizing a document the user was never cleared to see, and at the health plan that document would be another member's record. We treat that as a fixed rule in our enterprise AI strategy work, along with giving every retrieved passage an ID you can trace.
The table below is how we map the main frameworks to what we build. The health plan would mostly care about the HIPAA and SOC 2 rows, while a bank or payments company would usually answer to three or more of them at once.
|
Framework |
What the auditor will ask |
What we'd show them |
|---|---|---|
|
HIPAA |
Who saw this member's record, and were they allowed to? |
Retrieval scoped to the member and the nurse's role, encrypted indexes on HIPAA-eligible services under a BAA, and an access log for every hop |
|
SOC 2 |
How do you know what changed last Tuesday? |
Prompts, tools, and indexes in version control like code, plus a log of every plan and tool call |
|
PCI DSS |
Could a card number end up in the index? |
No, because card numbers are tokenized before anything is indexed |
|
GLBA, SEC, and FFIEC guidance |
Why did the system recommend that? And was it tested before it went out? |
The decision log with the evidence behind it, plus challenger-model test results for every release and its entry in the model inventory |
|
GDPR |
A customer asked to be forgotten. Is anything of theirs still in the system? |
Not once the deletion reaches the embeddings and cached answers, and none of it left the EU Regions to begin with |
|
EU AI Act (high-risk uses) |
Is there a log of what the system did, and can a person overrule it? |
Automatic event logs under Article 12, and a person who signs off on consequential actions under Article 14 |
For European operations, the clock has moved. Under the EU's Digital Omnibus amendments to the AI Act, adopted as Regulation (EU) 2026/1744, high-risk obligations for Annex III systems now apply from December 2, 2027, and AI embedded in regulated products follows on August 2, 2028. We'd use the extra time to build logging and oversight in now, since retrofitting them after an auditor asks costs far more.
In the US there's no comprehensive federal AI statute to map against, so the working baseline is sector regulation plus the NIST AI Risk Management Framework. NIST's Center for AI Standards and Innovation also launched an AI Agent Standards Initiative in February 2026, with agent security and identity among its focus areas, which tells you where auditor questions are heading.
That's the approach we took on the KlearTrust HIPAA claims platform: PHI-safe retrieval, an authority boundary for the agent, and audit evidence captured at decision time. A six-month manual review cycle was replaced by a production system in twelve weeks, and the platform passed HIPAA and internal audit on first review. For a health plan like the one in our example, the same controls sit at the center of any healthcare data platform we put into production.
What Does Agentic RAG Cost to Run, and How Should a CFO Model It?
Below is the back-of-the-envelope model we walk through with finance teams. It uses AWS list prices for retrieval in the Amazon Bedrock Managed Knowledge Base, the token multipliers from the ACL 2026 study, and a placeholder model price you'd swap for your own.
Assumptions:
- 100,000 queries per month.
- Standard path: 4,000 input tokens and 400 output tokens per query, plus one Retrieve call at $1.00 per 1,000 calls.
- Agentic path: token use scaled 3.3x for input and 1.9x for output (13,200 and 760 tokens), plus one agentic retrieval call at $4.00 per 1,000 and four underlying Retrieve calls at $1.00 per 1,000. In AWS's own benchmark runs, agentic calls averaged roughly two to five retrieval hops.
- For the model itself, an illustrative $3 per million input tokens and $15 per million output tokens.
- We left out storage, evaluation, and people costs, since they're about the same for every design.
|
Design |
Model tokens |
Retrieval |
Monthly total |
Cost per query |
|---|---|---|---|---|
|
Standard RAG for everything |
$1,800 |
$100 |
$1,900 |
$0.019 |
|
The agent on every query |
$5,100 |
$800 |
$5,900 |
$0.059 |
|
Routed, with 60% standard and 40% agentic |
$3,120 |
$380 |
$3,500 |
$0.035 |

Routing does most of the work here. Sending simple questions down the standard path cuts the bill by about 40 percent compared with putting everything through the agent. The other thing the model shows is that tokens are rarely what sinks the business case. The things that do sink it tend to be these:
- Engineering time for evaluation and observability that nobody budgeted for.
- Hours that reviewers spend on escalations, because nobody drew the authority boundary clearly enough.
- Rebuilding a pilot that was made for a demo once someone decides to put it into production.
We'd keep the per-query number in check by capping agent steps and token budgets, caching repeat retrievals, planning with a smaller model such as Amazon Nova 2 Lite, and running offline evaluation through batch inference. We'd also measure cost per resolved task next to cost per query, because an answer that gets escalated carries the cost of both the agent and the reviewer. At the health plan, a recommendation a nurse has to redo costs more than one the nurse just signs.
As for where the money comes from, it's usually already in the building. In the words of our point of view on funding AI: “Most of the AI budget you think you need is already in the building. It is paying interest on the old stack.” Legacy database licenses, integration tiers that bill hours to stay alive, and warehouses nobody runs new workloads on are all candidates for reallocation, which turns AI from an R&D line into a capital allocation decision. That matters, because McKinsey found only 37 percent of respondents attribute any EBIT impact to AI so far, about the same as a year earlier.
Why Do Agentic RAG Pilots Stall Before Production?
Dan Marks, our VP of Business, put it this way in Agentic AI: The Production Path:
“In the agent programmes reviewed, the technical blocker was almost never the model. Plenty stalled on one of three things: an authority boundary nobody had written down, an evaluation set nobody had built, or a source system nobody had assessed. The programmes that shipped fastest spent their first fortnight on the paperwork most teams treat as a distraction.”
That matches what we see. The table below is the failure-mode list we review with every client before go-live, with the fix we put in for each one.
|
Failure mode |
What you see |
Root cause |
Production fix |
|---|---|---|---|
|
Runaway loops |
Token bills spike and latency climbs |
No step cap or stop condition |
Hard step and budget limits, with a fallback to the standard path |
|
Permission leakage |
Users see content they shouldn't |
Filtering after retrieval |
Entitlements enforced inside the query |
|
Prompt injection through documents |
The agent follows instructions hidden in retrieved text |
Retrieved content treated as trusted |
Guardrails prompt-attack filters, tool allowlists, and provenance tags |
|
Retrieval drift |
Accuracy drops after re-embedding or a model swap |
No regression suite |
Golden-set regression in CI before every index or model change |
|
Stale index |
Answers quote a policy that's been replaced |
Nobody set a freshness SLA for batch ingestion |
We'd sync on events and show freshness dates in citations |
|
Tool-call cascades |
One failed API call takes the whole task down |
Tools don't retry or handle partial results |
We'd make tools idempotent, add circuit breakers, and escalate cleanly |
|
Judge bias |
Offline scores look great, and users still disagree |
An LLM grades LLM output and nobody calibrated it |
We'd keep a human-labeled calibration set and review it monthly |
At the health plan, the two failures we'd worry about most are the second and the fifth: a nurse seeing another member's record, and a recommendation that quotes last month's policy. Neither has anything to do with the model. In fact only one of the seven really does, and the rest come down to data, identity, and operations, which is why we spend less time on the RAG vs. AI agents debate than clients expect and more on getting retrieval and agency to behave together under real load.
How Do You Evaluate and Observe Agentic RAG Before and After Go-Live?
Leaderboards won't tell you whether an agent will work on your contracts or your claims. On one knowledge benchmark alone, AA-Omniscience, Stanford's 2026 AI Index found hallucination rates anywhere from 22% to 94% depending on the model, and with a spread like that your own evaluation set has to be the source of truth. We'd build that set at the health plan from a few hundred past prior-authorization requests, including the messy ones.
|
Metric |
What it tells you |
Starting gate we typically set (tune to your risk) |
|---|---|---|
|
Retrieval recall@k and NDCG |
Whether the right evidence was found and ranked |
A baseline from your labeled set, and no release that regresses it |
|
Faithfulness (groundedness) |
Whether claims are supported by the retrieved evidence |
0.9 or higher on the golden set |
|
Citation accuracy |
Whether cited sources actually say what the answer claims |
100% on regulated answers |
|
Tool-call accuracy |
Whether the agent picked the right tool with valid inputs |
95% or higher before write access is granted |
|
Task success rate |
Whether the job got done without a human redo |
Agreed with the business owner for each use case |
|
Steps and cost per resolved task |
Whether agency is paying for itself |
Tracked weekly against the routed baseline |
|
p95 latency |
Whether users will wait for it |
Set by the workflow, not the engineering team |
|
Escalation rate |
Whether the authority boundary is set correctly |
Trending down after launch, with spikes triggering a review |
Say the health plan swaps in a newer model in March. Before it goes live, the change runs against the golden set in CI, and if faithfulness drops on the prior-authorization cases, it doesn't ship. After launch, AgentCore Observability traces each hop with OpenTelemetry, so the team gets alerts on step counts, grounding failures, and policy denials in the same place it already watches error rates.
When a metric slips, the cause is more often the data than the model. Gartner found in 2026 that organizations with successful AI initiatives invest up to four times more, as a share of revenue, in data and analytics foundations, and our point of view on why most enterprises will fail at agentic AI explains why source readiness belongs in week one of any agentic retrieval program.
How Long Does Agentic RAG Implementation Take to Reach Production?
With a scoped use case and an accountable owner, about 12 weeks, which is also the median from kickoff to production across Mactores engagements. Here's the plan we run, with a customer-signed exit at the end of each phase and a forward-deployed engineer owning the judgment calls, as described in how we work.
|
Weeks |
What gets done |
Exit criteria |
|---|---|---|
|
1 to 2 |
Write the authority boundary, assess source systems, and build the first golden evaluation set |
Signed scope, a named owner, and a labeled evaluation set |
|
3 to 5 |
Ingestion, indexing, permission-aware retrieval, and an enhanced RAG baseline |
Baseline scores recorded, and entitlement tests pass |
|
6 to 8 |
The agent loop, tools through MCP, guardrails, policy, and memory |
Tool-call accuracy and step limits meet the gate |
|
9 to 10 |
We red-team the agent, test it against prompt injection, and assemble the compliance evidence pack |
Security and compliance sign-off |
|
11 to 12 |
The agent runs in shadow mode, then rolls out in stages, and we cut over with runbooks in place |
It's handling production traffic and the business owner has accepted it |
Hibu's project shows why the dull work goes first. Its retrieval layer, a purpose-built MCP connector that gives Claude hybrid keyword and semantic search over an OpenSearch index of 1.82 million inbound lead calls a month, was finished before the agent layer went live. Questions that used to sit two to three days in an analyst queue now get answered in under five minutes.
Should you build it yourselves or bring in a partner? Here's the gut check we'd use:
|
Question |
Build in-house if |
Bring in a partner if |
|---|---|---|
|
Team |
Your engineers have already shipped agents to production on AWS |
Your team is strong on apps or data and new to agents |
|
Timeline |
No board or regulatory date is attached |
A date has been committed to the board or a regulator |
|
Risk |
Low-risk internal use |
Regulated data or consequential actions |
|
After go-live |
You plan to staff a permanent agent platform team |
You want your team to own it, with the heavy lifting done once |
If the answers point to a partner, our generative AI consulting work covers the retrieval side of agentic RAG, from precision and recall to faithfulness against source documents, on the same fixed-date, fixed-fee terms as the rest of what we ship.
Frequently Asked Questions
Is agentic RAG always better than traditional RAG?
Not for everything. It burns more tokens and takes longer, so for a single-source lookup it's money you didn't need to spend, and the ACL 2026 study found neither design wins across the board. What we build in production is a router that sends easy questions to enhanced RAG with hybrid search and reranking, and only hands the hard ones, or the ones that end in an action, to the agent.
Which vector database should we use for agentic RAG on AWS?
With the Bedrock Managed Knowledge Base, you don't choose, because AWS runs the vector storage. If you're running your own, we'd usually start with Amazon OpenSearch Serverless for fast hybrid search, consider Amazon S3 Vectors for very large collections where a bit more latency is fine, use Aurora PostgreSQL with pgvector if the team already lives in Postgres, and add Amazon Neptune Analytics when relationships matter enough for GraphRAG. Many production systems end up with two.
How long does it take to deploy agentic RAG in an enterprise?
About 12 weeks for a well-scoped use case. The first two go on the authority boundary, the source systems, and the evaluation set. Weeks three to ten build retrieval, the agent loop, guardrails, and the compliance evidence, and the last two are shadow mode, a staged rollout, and cutover.
Should we build agentic RAG in-house or bring in a partner?
If your engineers have already put agents into production and nobody has promised a date, building in-house makes sense. We'd bring in a partner when the data is regulated, the agent will take consequential actions, or the board has been given a date. Whoever builds it, the scope and date should be in the contract, as they are in our delivery commitment, and your team should own the system at the end.
What is agentic RAG in simple terms?
It's RAG where an AI agent does the searching instead of a fixed pipeline. If a nurse at the health plan asks a plain RAG assistant about a knee MRI, she gets the policy text back. The agentic version will also pull the member's eligibility and claims, notice that the physical therapy record is missing, go and look for it, and then come back with a recommendation that cites each source.
How much more does agentic RAG cost than standard RAG?
Roughly three times as much per query, if every request goes through the agent. In our model that was $0.059 a query against $0.019 for standard RAG, mostly because of the extra input tokens and retrieval calls, and routing 60 percent of traffic to the standard path brought it down to $0.035. We'd still budget more carefully for evaluation, observability, and reviewer time than for tokens.
Can we add agentic capabilities to our existing RAG pipeline?
Yes. Most of the agentic programs we'd scope start from an existing RAG pipeline, keeping its ingestion, embeddings, and index and adding a router, query decomposition, a verification step, and approved tools. On AWS, the Bedrock knowledge base you already have becomes one of the agent's tools on AgentCore, so very little of the first build gets thrown away.
How do we stop agentic RAG from exposing documents users shouldn't see?
The rule we'd follow is that the user's permissions go into the retrieval query, not onto the results. Say a nurse asks about a member she isn't assigned to. With permissions in the query, the agent never sees that member's file. With filtering afterward, it has already read the file and may have used it, and no amount of trimming fixes that. We'd also pass her identity into every tool call, log each hop, and keep entitlement tests in CI.
Does agentic RAG fall under the EU AI Act high-risk category?
It can. The EU AI Act looks at what a system is used for, so an agentic RAG tool that helps decide credit, hiring, life or health insurance pricing, or access to essential services can fall under Annex III, with obligations from December 2, 2027. An internal search tool for policy documents usually won't. If there's a chance yours qualifies, it's far cheaper to build the record-keeping and human sign-off in now than to add them later.
Written by
Gautham B
Forward-Deployed Engineer, Data Engineering practice.
Keep reading
Next in AI Agents for Apps.
Let's deliver
Bring us the process. We will bring the authority model.
The agent-native AWS modernization firm. Data platforms moved. Legacy retired. AI agents in production. AWS Premier Tier Services Partner since 2026, on AWS since 2008.
- 01 AWS Premier Tier Services Partner, on AWS since 2008.
- 02 Forward-deployed engineers own architecture, cutover and the date.
- 03 Acceptance criteria per phase, with the signer named in the SOW.
- 04 The golden set and the trace data belong to you.

