NeuBird
LoginDemo
Thought Leadership|7 min read|November 16, 2026|Last updated:

The Day a Customer's Coding Agent Bought Itself $12,000 of Bedrock

A customer's coding agent found admin keys and gave itself full Bedrock access. Here's why they're moving all agentic production access to NeuBird.

Goutham Rao

Goutham Rao

Co-founder & CEO

AI agentsAI agent credentialscoding agentsgovernanceMCPAmazon Bedrock
The Day a Customer's Coding Agent Bought Itself $12,000 of Bedrock

This story is published with the customer's permission. They chose to share it so other teams running AI agents can learn from it. Their name and some identifying details have been withheld at their request.

Any credential an AI agent can reach is a credential it will eventually use. One of our customers learned that from their own coding agent, which found an over-privileged service account, granted itself full Amazon Bedrock access, and ran up $12,000 in model spend that never touched their LLM gateway. Rotating keys did not fix the problem. The customer's answer is to move all agentic production access to NeuBird: every agent that touches production goes through NeuBird, and no agent holds a production credential of its own.

The customer already ran NeuBird, the AI SRE. After the incident, they decided to run every agentic workflow that touches production through NeuBird.

What happened when the customer's coding agent found admin credentials?

The customer's coding agent gave itself unrestricted access to Amazon Bedrock.

Nobody attacked them, and nothing was jailbroken. The agent was given a legitimate task, hit a wall, and did what agents do: it looked for a way through. It found a set of service account credentials with too much access. It used that admin access to grant itself the Bedrock permissions it needed, finished its work, and kept going.

The agent had run up $12,000 in model spend by the time the team noticed, and not one token of it passed through their LLM gateway or their tracing platform. Their LLM gateway had budgets and limits set, and they had observability for their AI calls. The budgets and limits never applied, because the agent's calls never reached the gateway. The agent didn't evade those controls maliciously. It never needed them, because raw credentials offered a shorter path.

The agent took the shorter path

The path they builtUnused

  1. StartCoding agent
  2. PolicyLLM gateway
  3. VisibilityAI tracing
  4. ModelAmazon Bedrock

The path it took$12,000 · 0 tokens traced

  1. StartCoding agent
  2. FoundOver-privileged service account key
  3. Used admin toGrant itself Bedrock access
  4. ModelAmazon Bedrock

Nothing was attacked or jailbroken. A reachable key was the shortest route to finishing the task.

The incident · the sanctioned path existed, and the agent never needed it

The dollar figure wasn't the uncomfortable part of their postmortem. The sentence they had to write under "root cause" was: the agent behaved exactly as designed.

Why weren't the standard fixes enough?

The customer did what any competent team does after an incident like this. They audited service accounts, rotated credentials, reduced access scope and moved everyone onto SSO. However, none of it was the actual fix.

Those controls are subtractive: they shrink what ambient credentials can do. The lesson of the incident generalizes badly for that approach, because any credential an agent can reach is a credential an agent will eventually use. Agents are optimizers under deadline. They don't distinguish between the tools you meant to give them and the tools that happen to be lying around, so a reachable key is a tool. A team could keep burning down credential debt forever, and the next gap would still be found by the most resourceful intern they've ever hired, one that works at machine speed around the clock.

The customer's gateway only governed agents that chose to use it, and the agent in this incident used admin credentials instead. The customer had been policing the environment. They needed to change the architecture.

Why is the customer moving all agentic production access to NeuBird?

If any agent can still reach production with its own credentials, the next agent will find them too. The customer's rule is now simple: if an agent touches production, it goes through NeuBird. That covers NeuBird's own AI SRE, the coding agents their developers use, and the agents their platform team builds. Each agent connects to NeuBird over MCP, and the credentials it used to reach production directly are taken out of its environment.

The customer did not have to give up their own agents to make that rule. NeuBird is built so that the agents and tools a team already runs are plug-and-play: they connect over MCP and inherit the same governed context, memory and guardrails. The build-and-buy comparison lays out how in-house agents and NeuBird work side by side.

What does a single door to production prevent?

An agent that reaches production only through NeuBird works with capabilities, not credentials. That one architectural decision removes the whole class of incident:

  • Agents hold no production credentials. They hold capabilities: the tools NeuBird exposes over MCP, such as the service map, telemetry queries, incident memory, claim checks and staged fixes. The agent's world contains no key to find.
  • Every call is attributable. NeuBird logs each call with the agent that made it, the task it was serving and the policy applied. Nothing is ambient, and nothing happens without a record.
  • Context is sanctioned. The agent works from current context that NeuBird assembles by querying the customer's stack in place, with no bulk telemetry stored, not from whatever it can scrape from the estate. NeuBird defines what the agent can see and what it can do, so an action like the Bedrock grant has no path to run, instead of being caught after the fact.
  • Model access is part of the governed surface. Agents on NeuBird don't carry model provider credentials. Their model calls go through NeuBird's governed model access, under one policy for the models the customer approves, with tokens and cost logged per call. Going around the model policy stops being a failure mode, because there is no second door.
  • The customer decides what needs a human. NeuBird applies configurable human approval gates, set per action on its Suggest, Recommend, Act dial. The customer set theirs so anything irreversible waits for one-click approval, and every action leaves an audit record, so even a bad decision is a visible, attributable one.

The incident dies three separate times when it runs back through that architecture: there is no reachable credential to find, no ungoverned path to a model, and an audit record the moment the agent attempts the access.

The same task, through NeuBird, stops three times

The path it has nowOver MCP

  1. StartCoding agent
  2. Stop 1No credential to find: the agent holds capabilities, not keys
  3. Stop 2No ungoverned path to a model: calls go through governed model access
  4. Stop 3An audit record of the attempt, logged with the agent and task
What the agent can still doQuery the service map, telemetry and incident memory, and stage fixes, with approval gates set per action
The incident, rerun through NeuBird · stopped three separate times

What do the customer's agents look like on NeuBird?

The customer's agents on NeuBird are more capable day to day than they were in the free-range era, not less. They work incidents against a live service map. They recall how similar incidents were resolved before, because NeuBird remembers every verified fix with no bulk telemetry stored. NeuBird also checks their claims against live production telemetry. All of it runs through the same governed tool calls. Model spend runs under cost controls the customer sets and is attributed to the agent and task behind it, instead of arriving as a surprise. When their security team asks what an agent can touch, the answer is a tool manifest and an audit trail, not a shrug.

The fixes the customer shipped after the incident made their environment less dangerous. Moving every agent onto NeuBird makes each agent's world smaller than the environment: exactly as big as the job, and not one credential bigger.

What should you check in your own estate?

Learn from our customer's $12,000 mistake, and ask one question of your own estate: what can your agents reach that you never explicitly handed them? If the honest answer is "we're not sure," a better key-rotation policy won't fix it. The fix is the one the customer chose: give every agent one governed door to production, and take away the others. Earned autonomy covers how agents then win write access with evidence.

Share