Introduction
Imagine you let an AI agent run queries on your production data. You ask it for a sales total. It reasons that the fastest route is to restructure the table first, so it drops an index. The agent isn't malicious. It's just optimizing for the goal you gave it.
Nobody reviewed the statement before it ran. You've probably heard the pitch for AI that "acts" on data. This scenario is what that pitch leaves out. The technical term for it is excessive agency, and in 2026, you can no longer treat it as a rare edge case.
A data agent isn't a chat window that writes queries. It's a software entity that accesses diverse data sets, tools, and applications to execute its mission. Without a strict architectural leash, that mission drifts the moment the model finds a shortcut.
This article explains what a data agent is and the security controls that keep it safe, including AWS execution roles and NIST’s proposal for a separate credential per agent. Without its own bounded identity, an agent is just an unauthorized script with a better résumé.
Key Takeaways
A data agent is not a chatbot by definition, and treating it like one is the fastest path to a production incident. Here are the architectural non-negotiables that separate a reliable data agent from a dangerous one:
- Fundamental difference: A data agent autonomously orchestrates multi-step workflows and mutates state, while a chatbot is confined to conversational response generation.
- Identity is everything: NIST's February 2026 draft recommends treating agents as distinct entities with bounded authorization. No identity, no production access.
- BYOC is not a luxury: Bring Your Own Cloud architecture guarantees customer data never leaves the data plane, inheriting your existing IAM and network perimeter controls.
- Human handoffs are a feature, not a flaw: Requiring user confirmation for write operations converts a probabilistic model into a deterministic enterprise tool.
- Cost clarity exists: 2026 pricing combines flat subscription tiers with usage-based metering. The introductory at-cost rate we see in the market is $0.14 per OLU, with standard pay-as-you-go settling near $0.20 per OLU.
What Is a Data Agent?
A data agent is an AI system that works toward a goal on your data from start to finish. It inspects the schema, plans multiple steps, runs queries, and can take actions like updating a dashboard or writing to your CRM.
That last part is what separates it from a chatbot, which only replies in text. This matches how Google Cloud defines the term.
How a Data Agent Differs from a Chatbot

Ask a chatbot for the Q3 revenue total, and it will generate a plausible SQL string and hand it to you. Ask a data agent the same question, and it will inspect the schema, execute the query, pivot the result set, and write it back to a dashboard.
One is a scribe. The other is an autonomous partner. The definition PromptQL uses matches what Google Cloud codified: a data agent is an intelligent, goal-oriented system that is designed to solve complex enterprise data problems, acting as an autonomous partner from start to finish.
That "from start to finish" clause is the dividing line. A coordinated data agent understands deep context like schema and permissions, gathers and synthesizes information from diverse sources, and acts as a goal-oriented problem-solver with multi-step plans and alternative approaches. It uses tools including machine learning models and other agents.
The moment you give the system a tool that can mutate state, an INSERT, a DROP, a PATCH call to your CRM, you have crossed out of chatbot territory. The comparison table below shows exactly what shifts.
| Capability | Chatbot | Data Agent |
|---|
| Core function | Generates conversational responses | Autonomously orchestrates end-to-end data workflows |
| State interaction | Read-only suggestion | Executes tool calls and mutates production state |
| Architecture | Single-turn LLM call | Coordinated system with a reasoning engine, data context layer, and orchestration engine |
| Planning | None | Multi-step with alternative fallback paths |
| Autonomous classification | N/A | Ranges from L0 (no autonomy) to L5 (full autonomy) |
Why Traditional AI Architectures Break with Enterprise Data

Standard Retrieval-Augmented Generation (RAG) pipelines fail on permission-aware enterprise tasks because they have no persistent identity loop. The model retrieves the right document but executes the query as a generic service account with god-mode access. 65% of data breaches in 2023 involved internal actors, and in 68% of those cases, human error was a main factor. Giving an unauthenticated reasoning engine write access under those conditions is indefensible.
The Tsinghua University DB group's taxonomy maps the gap precisely. Most enterprise deployments today are stalled at L2, partial autonomy, where the agent drafts a plan but a human must execute the final step. The jump to L3, conditional autonomy under supervision, requires the agent to operate within a bounded identity that inherits the user's exact permissions.
AWS frames the risk directly: agents introduce a risk called excessive agency, where an agent determines the best solution to a problem is to take broader actions beyond its scope. The architecture breaks because the model's reasoning engine has no programmatic knowledge of what behavior is permitted.
The only fix is an identity-first architecture that maps every tool call to a scoped IAM execution role, with the user's permission boundary as the constraint. Without it, every agent deployment is one clever chain-of-thought away from an incident.
The Security Imperative: Identity, Permissions, and Least Privilege for Agentic AI

The non-negotiable rule for 2026 is this: a data agent runs under its own distinct identity, with a scoped IAM execution role, and nothing else. Not a shared service account or an admin key.
AWS's Generative AI Lens is explicit: implementing least privilege and permissions bounded agents limits the scope of agentic workflows and helps stop them from taking actions beyond their intended purpose on behalf of the user. The risk level of not establishing this is classified as high.
It's tempting to skip this step. Wiring up fine-grained IAM for a new agent feels slower than just tossing it a broad role to unblock a demo. That shortcut is the entire attack surface.
The baseline architecture works like this. The agent's identity is a distinct IAM principal, not a proxy for a human, but a first-class entity with its own resource-bound policies. Every tool the agent can invoke, a SQL executor, a dashboard publisher, a CRM writer, is gated behind a permission that maps to a specific ARN.
When you ask the agent to refresh the Q3 pipeline data, the agent doesn't get access to the Q3 pipeline. It gets access to your authorized view of that pipeline, inherited at runtime. NIST's February 2026 concept paper puts it plainly: organizations need to understand how identity principles such as identification, authentication, and authorization can apply to agents.
This is not optional. App-level permissions are too porous when the agent's tool chain can side-step the API gateway. The enforcement point has to be the IAM layer itself.
You can see this in practice in PromptQL's own data-access layer, which was originally built for regulated data environments at companies including Meta, Apple, UnitedHealth, and JPMorgan Chase. The AI inherits a real user identity, and PromptQL injects credentials at runtime, so the model never sees the database connection string. You can't ask the agent to access another user's data.
If an agent tries to reach a table outside the caller's scope, the query fails with a standard IAM denial, logged and auditable. This is what a secure agent boundary looks like in production. The model can propose any plan it wants.
The IAM boundary collapses the blast radius to the permission set of the person who invoked it. That is the only safe default.
How BYOC Architecture Keeps Your Data Under Your Control
The cleanest way to enforce an identity boundary is to colocate the agent with the data it is allowed to touch. Bring Your Own Cloud (BYOC) does exactly this. It deploys the data agent's runtime inside your VPC, with your IAM, service control policies, and network perimeter controls as the active enforcement surface. The data never leaves the trusted boundary because the compute that processes it sits inside that same boundary.
BYOC uses a split responsibility model that maps naturally onto existing enterprise security operations. The control plane handles auth, billing, and observability and runs in the vendor's cloud. The data plane, every query execution, every Python sandbox process, every intermediate table scan, runs entirely in your cloud environment. Customer data never leaves the data plane. The vendor's control plane metadata, thread titles, task completion status, remains separate, and if you provision a data plane outside the US, sensitive application data stays in that region while that limited control metadata remains in the US.
This isn't a forward-looking claim. It is Generally Available on AWS today and available in beta on GCP and Azure. PromptQL structures this as a customer-owned data plane living in your AWS, GCP, or Azure environment.
In a BYOC deployment, conversation history stays in your cloud under your own key management. Credentials and secrets stay in your vault.
The model is never handed raw credentials. It receives scoped, runtime-injected tokens that inherit the caller's permission set.
The operational contract matters. Your existing monitoring and logging tools can see exactly what the agent is doing because every tool invocation generates a standard CloudTrail or equivalent event. There is no separate audit surface to maintain. The agent is just another compute resource running under your existing governance policies. That is the entire point.
Practical Reliability: Sandboxing, Human Handoffs, and Deterministic Execution

The safety net that converts a probabilistic agent into a reliable enterprise tool has three layers:
- Sandboxed execution: All Python execution happens inside a WebAssembly sandbox. Only the standard library, numpy, pandas, openpyxl, and reportlab are available. No pip install at runtime. No file system access outside the sandbox. This is a hard constraint. The sandbox cannot escape to make a network call.
- Mandatory human handoffs for mutation: Every tool invocation that would mutate state triggers a user confirmation step. The agent presents the exact statement it intends to execute, and a human approves it. AWS is direct about this: user confirmation steps mitigate excessive agency by requiring approval before actions execute. Writes and external calls require approval. Reads increment the usage meter without blocking. Analysis flows uninterrupted. Every write creates a specific, auditable confirmation event.
- Deterministic function wrappers: Non-deterministic LLM outputs are wrapped in deterministic function calls with strict schemas. The model decides which function to invoke. The function's implementation is a fixed, tested code path. This replaces the failure mode where an LLM improvises a SQL statement with a pattern where it selects from a pre-validated library of operations.
Together, these three layers can turn what would have been a multi-day incident review into a three-second authorization check. The intent surfaces for review, and the action is blocked.
What a Data Agent Costs in 2026: Pricing Models, Metering, and a Cost-per-Task Example

Pricing in 2026 has settled into a predictable combined model, and the market has converged around a few clear patterns:
- Subscription tiers map to deployment isolation: A standard plan runs on shared infrastructure with pay-as-you-go metering. An Enterprise plan includes dedicated VPC or BYOC deployment, single-tenant infrastructure, forward-deployed engineering support, and single sign-on. Custom plans bring your own models and self-hosted deployment options.
- Usage metering is consolidating around a unified compute unit: Rather than separate tokens, infrastructure, and sandbox hosting charges, the unit to know is the Outcome Logic Unit (OLU). The introductory at-cost rate you'll see is $0.14 per OLU, with standard pay-as-you-go settling near $0.20 per OLU. Every OLU covers tokens, infrastructure, and sandbox hosting. No separate platform fee or hidden infrastructure bill.
- Cloud providers are following the same trajectory: Google Cloud lists Data Cloud agents at $3 per million input data tokens and $20 per million output data tokens. Their pricing includes a free trial of all Data Cloud agents through December 31, 2026, after which the new rates go into effect. Data Insights pricing starts on October 27, 2026.
- A real cost-per-task example looks like this: Take a multi-step analysis task that scans 8 million tokens of input, executes three Python data transformations in the sandbox, writes a dashboard panel, and generates a 500-token summary. At the market's standard $0.20 OLU rate with a task that consumes roughly 4.5 OLUs, the total cost is approximately $0.90. A comparable manual workflow, where an analyst writes the queries, builds the intermediate tables, configures the dashboard panel, and writes the summary, takes about 90 minutes. The unit economics are not close.
Conclusion
When a data agent goes into production, ask one question: what can it actually touch? The model matters less than the permissions boundary around it. Without a distinct IAM principal, without BYOC data residency, without sandboxed execution and a human confirmation gate on every write operation, don't sign off.
That's the line to hold in 2026. And the architecture described here is not a white paper. It is running on AWS, GCP, and Azure right now.
Here's how to start:
- Start with a BYOC trial. Respect your existing IAM policies from day one.
- Connect a non-production data source. Use the same permission boundaries your human analysts get.
- Run read-only workloads first. Watch the audit trail.
- Add write operations one tool at a time. Keep confirmation gates on.
Maximum autonomy is not the target on day one. The target is an agent whose autonomy fits inside the permissions you already trust.
Frequently Asked Questions
What exactly is a data agent and how does it differ from a regular chatbot?
A data agent is an AI system that autonomously orchestrates multi-step data workflows and mutates state through tool calls. A chatbot only generates conversational responses. If it can execute a SQL DELETE or write to your CRM, it is an agent, not a chatbot.
Why are traditional AI architectures unreliable when working with enterprise data?
Traditional RAG pipelines lack a persistent identity loop. The model retrieves data but executes tool calls as a generic service account, creating excessive agency risk where the agent takes broader actions than intended. Scope must be bounded by IAM, not prompts.
How do data agents handle security, permissions, and user identity?
A data agent runs under its own distinct IAM execution role with least privilege access. Permissions are scoped to specific resource ARNs, and the agent inherits the real identity of the user who invoked it. Credentials are injected at runtime, the model never sees database connection strings.
What are the key benefits of deploying a data agent with a BYOC (Bring Your Own Cloud) architecture?
BYOC deploys the agent's data plane inside the customer's VPC. Data never leaves the customer's cloud, existing IAM and SCP controls apply directly, and all agent actions generate standard CloudTrail events under the customer's own audit and key management.
How is AI reliability achieved in natural language data operations?
Reliability comes from three layers:
- Sandboxed execution: All code runs in a WebAssembly environment, preventing any system-level side effects from directly affecting the host machine.
- Human-in-the-loop confirmation: Every write operation requires mandatory human approval before execution, ensuring that no unintended changes are made without oversight.
- Deterministic function wrapping: Non-deterministic LLM outputs are encapsulated in pre-approved function calls with strict schemas, enforcing predictable and safe behavior.
What factors influence data agent pricing and what are typical cost components in 2026?
Pricing combines subscription tiers (Standard, Enterprise, Custom) with usage-based metering. Cloud providers charge per input and output token. Standalone platforms use unified compute units (OLUs) covering tokens, infrastructure, and sandbox hosting, around $0.14 to $0.20 per OLU.
Sources
- Policy-based access for the agent era - promptql.io
- GENSEC05-BP01 Implement least privilege access and permissions boundaries for agentic workflows - Generative AI Lens - docs.aws.amazon.com
- Accelerating the Adoption of Software and AI Agent Identity and Authorization - www.nccoe.nist.gov
- Data Agents: Levels, State of the Art, and Open Problems - dbgroup.cs.tsinghua.edu.cn
- [PDF] Google Cloud - Data Agents Guidebook - services.google.com
- Access control and permission management for AI agents: building with security in mind - www.cerbos.dev
- Data Agents pricing | Google Cloud - cloud.google.com
- Bring Your Own Cloud (BYOC) - Docs by LangChain - docs.langchain.com
- BYOC Architecture | Redpanda Cloud - docs.redpanda.com