A coding laptop, task calendar, and miniature cloud server sit on a developer’s desk.

AWS Kiro Bots and AI Agents: Standing Jobs, Schedules, and the Emulator Agents Built

Key Takeaways

  • AWS made Kiro bots generally available on 5 November 2026 in Kiro Crew. A bot is a named, long-running AI agent with one standing job, its own memory, its own permissions, and a schedule — not a one-off chat session.
  • Each bot keeps its own notes and conversation between runs, can launch and supervise parallel worker sessions, and brings work back for a human to review. A code review bot, for example, can review code but cannot approve or merge it.
  • There is no per-bot fee: bot work draws on the same credits as other Kiro use. The Pro plan is $20 per user a month for 1,000 credits, with extra credits at $0.04 each — but AWS has published no figure for what a continuously running bot costs.
  • Six days later, on 11 November 2026, AWS released AWS Emulator, a free local copy of more than 200 AWS services that runs on a developer's own machine with no account — and AWS says autonomous AI agents wrote every line of it.
  • The emulator is built from more than 400 API models, runs as a local HTTP server in Rust, and is released under a CC0 public-domain dedication with its full commit history on GitHub.
  • Both releases have real limits: AWS published no productivity benchmarks or error rates for Kiro bots, and the emulator does not simulate throttling, outages or regional differences, does not sandbox code, and is not suitable for security testing.

Two Releases, One Week, One Direction

In the space of six days in November 2026, Amazon Web Services shipped two things that, taken together, say more about where AI-assisted development is going than either one does alone. On 5 November, it made Kiro bots generally available in Kiro Crew — persistent AI agents that own a standing job on a development team. On 11 November, it released AWS Emulator, a free local stand-in for the AWS cloud — and announced that autonomous AI agents had written every line of it, with no human writing or reviewing any of the code.

The two releases are different products, but they share a premise. The first assumes that AI agents are no longer a tool you open for a single task and close again, but colleagues with ongoing responsibilities. The second assumes that agents are now capable enough to build serious infrastructure, and cheap enough to run in a loop against the real cloud until they get it right. This article explains both: what Kiro bots are, what they cost, who they are for, and what the emulator is, how agents built it, and where it falls short.

What Kiro Is, and Where Bots Fit

Kiro is Amazon Web Services' agentic coding tool, available as an integrated development environment, a command-line tool and a web app. It first launched on 14 July 2025 and reached general availability on 7 May 2026. Kiro Crew is its workspace for running many agents side by side. Crew evolved out of an internal Amazon project called MeshClaw and was first released in August 2026. According to AWS's Kathy Kam, speaking to The AI Economy, the internal Amazon tool that became Kiro Crew drew 39,000 Amazon builders within six months — a figure that explains why AWS is investing in it as a platform rather than a feature.

Bots are the newest layer on top of Crew. The Kiro blog post that announced them, "Introducing Bots in Kiro Crew", published on 5 November 2026, opens with a morning that most developers who use agents will recognise: several agents running at once, each doing a different job, and the developer trying to keep track of all of them. Bots are AWS's answer to that problem. Instead of starting a fresh agent session for every recurring task, a developer gives the job to a bot — a named, long-running agent that keeps the job until it is changed.

A bot, as AWS describes it, has a name and an avatar, a continuing conversation, its own memory, its own workspace and a dashboard. It keeps notes on decisions and unfinished work, so that context survives between sessions. It can launch parallel worker sessions, monitor their progress, redirect work that drifts from the plan, and consolidate results into one chat. It can run on a schedule, checking something every 30 minutes or every morning, and it brings work back for a human to review rather than acting on its own authority.

The distinction that matters most is between a bot and a session. A session is a one-off conversation: you ask, the agent answers, the conversation ends, and the context is gone. A bot is a standing responsibility: it has a job, it remembers what it did last time, it knows what it is allowed to do, and it keeps doing the job until someone tells it to stop. That is a small difference in description and a large difference in practice, because it changes the agent from a tool into something closer to a team member with a defined role.

What a Kiro Bot Actually Does

AWS described four example bots in its announcement, each with different access, and the examples are the best way to understand what bots are for. The jobs are the repetitive, ongoing chores of software teams — the work that is important, unglamorous, and easy to forget.

A build-health bot watches the continuous-integration pipeline and checks it every 30 minutes, reporting when a build fails and what changed. An issue-triage bot sorts new tickets as they arrive, labelling them and routing them to the right person or queue. A code-review bot reads changes and leaves review comments — but, pointedly, it cannot approve or merge code. That limitation is deliberate: the bot can advise, but the decision to merge stays with a human. A release-readiness bot checks whether a release is ready, gathering the status of tests, reviews and outstanding issues into one place.

Each bot gets only the tools and permissions its job needs. That is a security design as much as a convenience: a build-health bot does not need permission to merge code, and a triage bot does not need access to production secrets. If a bot's job changes, its permissions change with it, and adding new tools requires an approval step. The Crew page also describes a signed audit log for bot activity, so that what a bot did, and when, is recorded.

Memory is what makes a bot different from a prompt you re-run. AWS describes the memory feature as Notes: a bot saves developer preferences, prior decisions and project constraints, and carries them across sessions. Memory is tied to the bot's assignment, so a deployment bot's decisions stay separate from a research bot's context. AWS says bots improve through saved context and corrections, not by retraining the underlying models — the bot gets better at its job because it remembers what worked and what did not, not because the model underneath it changed.

Bots run where Crew runs, including on a laptop, a Mac Mini or an Amazon EC2 instance, and the coordinator and its workers can use different models. Kiro's catalogue includes OpenAI and Anthropic models alongside open-weight alternatives, with availability and credit charges varying by model. Setting one up is straightforward, according to coverage of the launch: open the bots workspace in the Kiro Crew sidebar, add a bot, then choose a default agent or a custom one as the starting point, with its prompt, model, tools and skills.

What Kiro Bots Cost — and What AWS Has Not Said

There is no separate per-bot fee. Bot work draws on the same credits as other Kiro use, and Kiro's pricing page lists the plans: Free at $0 with 50 credits, and Pro at $20 per user a month for 1,000 credits, with additional credits at $0.04 each. Teams of at least two pay $20 per seat for 500 credits per seat in a shared pool. Kiro Crew itself is free, open-source software under the Apache License 2.0, but it needs a Kiro plan to run, because the model reasoning — including scheduled reasoning — uses the account's plan credits.

The subscription price alone does not tell a team what a continuously running bot will cost, and that is the most important gap in the announcement. A bot that checks a build every 30 minutes runs 48 times a day, and each run consumes credits depending on the model, the size of the context, and the complexity of the task. AWS has announced no figure for that, and the launch announcement offers no benchmarks, no productivity results and no error rates. VentureBeat's report on the launch noted that absence explicitly, and it is worth repeating: there is no published evidence yet that Kiro bots save teams time or money, only a plausible mechanism by which they might.

That does not make bots a bad idea. It makes them an idea to test with a budget and a stop condition, rather than to adopt on the strength of the announcement. A team that gives a bot a standing job should know what it costs per week, what it gets wrong, and how often a human has to correct it — and AWS has not published any of those numbers yet. The sensible approach is to start with one bot, on one well-defined job, with a small credit budget, and to measure the result before adding more.

The AWS Emulator: A Cloud Built by Agents

If Kiro bots are about giving agents standing jobs, the AWS Emulator is about what agents can do with one. On 11 November 2026, AWS released AWS Emulator, a free local emulator of the AWS APIs that runs on a developer's own machine with no network connection and no AWS account. It is built from more than 400 API models covering more than 200 AWS services, and it lets developers and AI coding agents test code against a local stand-in for the real cloud.

The build story is the part that drew the attention. According to Matt Goldberg, the AWS senior principal engineer behind the project, "the emulator was written entirely by autonomous agents. Our team hasn't written or reviewed any of the code." The project started as a weekend experiment. Goldberg gave Kiro, AWS's coding agent, a three-step prompt and got a passable first version of Amazon SQS, the message queuing service, in 15 minutes. By the end of the weekend, Kiro had built a rough version of the rest of AWS, with obvious gaps, and Goldberg's team started using it to test its software that Monday.

The agents work from AWS's public API models, which describe how each service should behave, and check their work against the real AWS cloud. They run on Amazon Bedrock AgentCore in three teams. The project was inspired by Anthropic's demonstration earlier this year in which a team of Claude agents built a C compiler from a specification. Swami Sivasubramanian, AWS vice president of agentic AI and emerging tech, framed the project as a lesson about the changing job of engineers: less writing code by hand, more directing agents that write it.

The emulator itself is built in Rust and runs as a local HTTP server on Linux, macOS and Windows. AWS released it for free under CC0, a public-domain dedication, with the full commit history on GitHub — including the history of agents writing the code. AWS says it will share more at its re:Invent conference.

Why an Emulator Matters Now

The emulator addresses a problem that coding agents such as Kiro and Anthropic's Claude Code have made worse. Agents write code fast, and they test it by running it — which, for cloud software, means calling the real AWS cloud, over and over, in a loop. Each call costs money, takes time, and needs a network connection. A human developer might run a test suite a few times a day; an agent can run it hundreds of times, burning cloud spend and waiting on network round trips for every iteration.

The emulator lets that loop run on the developer's own machine. Code can be tested against a local copy of the AWS APIs without paying for the real cloud and without a network connection at all. That is useful for human developers too — offline work, fast iteration, no surprise bills — but it is most useful for agents, which are the heaviest users of test loops. It is also useful for learning: a developer who wants to understand how an AWS service behaves can experiment locally without creating resources in a real account.

There is an irony in the release that AWS itself leans into. The tool that lets agents test code cheaply was built by agents, using the same kind of loop it now enables: agents writing code, checking it against the real cloud, and iterating. Whether that is a demonstration of agent capability or a marketing story depends on how well the emulator actually works — and that is where the limits matter.

The Limits: What the Emulator Does Not Do

AWS and independent coverage are unusually candid about the emulator's limits, and they should be taken seriously. The emulator does not yet simulate throttling, outages, or differences in which services and features are available by region, according to an IDC analyst quoted by InfoWorld. It does not sandbox the code it runs. Unimplemented operations return HTTP 503 rather than fake success, which is the honest choice — a test that passes locally is not a guarantee of passing in production — but it means coverage is incomplete.

It is also not a tool for security testing. AWS says the emulator never denies a request signed with its own key and does not check bucket or key policies. A test that passes against the emulator says nothing about whether the same request would be allowed by real AWS permissions. Anyone who uses it to validate access controls will get a false sense of security.

The agents' own backlog of known gaps is public, in a GitHub folder called "things-that-do-not-work". That transparency is welcome, and it is also a measure of how much work remains. The emulator is a first release, not a finished product, and its value depends on how quickly that folder shrinks.

Who It Is For, and What to Watch

Kiro bots are for teams that already run several AI coding agents at once and need a way to organise them — teams with recurring jobs that are currently handled by a human remembering to do them, or by a script that cannot adapt. A solo developer with one agent and one project probably does not need a bot; a team with a build pipeline, a ticket queue and a release process might. The test is whether the job is genuinely recurring and genuinely well-defined. A bot with a vague job and broad permissions is a risk, not a helper.

The emulator is for developers and teams that test cloud code frequently, that work offline, that want to control cloud spend on test loops, or that are learning AWS. It is also, pointedly, for the agents themselves: the heaviest users of local cloud emulation will be the coding agents whose test loops the emulator was built to serve.

Two things are worth watching next. The first is whether AWS publishes any productivity or reliability data for Kiro bots — how much they cost to run continuously, how often they make mistakes, and whether teams that use them actually ship faster. Until that data exists, the case for bots rests on the mechanism, not on evidence. The second is the emulator's coverage: how quickly the "things-that-do-not-work" folder shrinks, whether throttling and regional differences get simulated, and what AWS says about it at re:Invent. Both releases are bets on the same idea — that agents are ready for standing responsibility. The next few months will show whether that bet pays off.

What We Could Not Verify

AWS has published no productivity benchmarks, error rates or failure data for Kiro bots, and no figure for the cost of running a bot continuously. Any claim about time saved or money saved by Kiro bots is unverified, and this article makes none. The figure of 39,000 Amazon builders using the internal tool behind Kiro Crew comes from AWS's Kathy Kam as reported by The AI Economy, and has not been independently confirmed. The emulator's coverage figures — more than 400 API models and more than 200 services — are AWS's own numbers, and no independent measurement of how faithfully the emulator reproduces real AWS behaviour has been published in the sources reviewed. The statement that no human wrote or reviewed any of the emulator's code is AWS's claim, reported by GeekWire and others, and it cannot be independently verified from outside the company.

For background on the agents these tools are built for, see our guide to what AI agents are and how they work, our AI agent security checklist for what to check before connecting an agent to any tool, and our guide to how much an AI agent costs for the hidden bill behind agent pricing.

Sources and Further Reading

  • Kiro, "Introducing Bots in Kiro Crew", 5 November 2026: https://kiro.dev/blog/crew-bots/
  • GeekWire, "AWS gives developers a free local stand-in for its cloud, built from scratch by AI agents", 11 November 2026: https://www.geekwire.com/2026/aws-gives-developers-a-free-local-stand-in-for-its-cloud-built-from-scratch-by-ai-agents/
  • Shashi Bellamkonda, "AWS Launches Kiro Bots So Developers Can Give AI Agents Standing Jobs", 6 November 2026: https://www.shashi.co/2026/11/aws-launches-kiro-bots-so-developers.html
  • StepPhase, "AWS Kiro Bots Reach General Availability: What They Do and What They Cost", 11 November 2026: https://stepphase.com/tech-news/aws-kiro-bots-general-availability/
  • DEV Community, "AWS releases an Emulator for its cloud written entirely by autonomous AI agents", 11 November 2026: https://dev.to/delimitter/aws-releases-an-emulator-for-its-cloud-written-entirely-by-autonomous-ai-agents-b43
  • Vanda Team, "AWS Emulator: What AI Agents Built and How Data Teams Use It": https://vandatateam.com/blog/aws-emulator

Similar Posts