AWS Kiro bots manage parallel agent sessions with persistent memory

Amazon Web Services has launched Kiro bots, a new feature within its Kiro agentic development environment designed to manage parallel worker sessions and maintain persistent memory. Released on November 7, 2026, this update aims to shift the developer role from manually coordinating individual AI tasks to overseeing autonomous, long-running processes that retain context across multiple interactions.

What happened

AWS first introduced Kiro in July 2025 as a spec-driven development environment, followed by Kiro Crew in August 2026, which provided an open-source workspace with cross-session context retention. The latest addition, Kiro bots, extends this capability by giving each agent its own durable memory and the ability to launch and monitor parallel sessions independently. This allows software engineers to define named, long-running agents customized for specific workflows, such as monitoring ticket queues or managing deployment pipelines.

The core problem AWS addresses is what engineers call "context rot," where developers must repeatedly ferry information between short-lived agent sessions. Without persistent memory, agents lose track of previous decisions, leading to redundant work and fragmented understanding of the project state. Kiro bots solve this by maintaining a dedicated memory file that persists across sessions, ensuring that corrections and learned constraints remain active without requiring manual re-entry by the developer.

Kathy Kam, director of engineering for AWS Agentic AI, emphasizes that trust in these systems comes from track records rather than abstract intelligence metrics. Each bot operates with a specific set of tools and permissions defined at creation, preventing unauthorized actions while allowing it to build competence in its designated area. For instance, a research bot may have read-only access to files and web search capabilities, while a deployment bot can execute scripts but requires human approval before making changes.

How it works

Each Kiro bot functions as an independent entity with its own memory store, implemented as a markdown file that both the bot and the developer can read and write. This file serves as the single source of truth for the bot’s current state, past decisions, and operational boundaries. When a bot starts a session, it references this file to understand its role and any prior context, eliminating the need for the developer to re-explain the task.

Bots can launch multiple parallel worker sessions to handle complex jobs, monitoring their progress and combining results upon completion. If a session drifts from the intended plan, the bot can redirect it automatically. Crucially, bots cannot delegate work to other bots; this design choice prevents the compounding of errors and ensures that each bot remains accountable for its specific domain. Developers connect bots to each other manually, maintaining control over how information flows between different parts of the workflow.

Communication with a bot happens through a dedicated chat channel where developers set direction and review outcomes. The bot can pause specific tasks to request human input while continuing to work on independent subtasks, optimizing overall throughput. Over time, the bot’s behavior adapts to the developer’s preferences and the project’s requirements, creating a personalized assistant that reflects the engineer’s unique working style.

Key details

• Kiro bots were released on November 7, 2026, as part of the AWS Kiro ecosystem.
• Each bot maintains its own persistent memory via a readable and writable markdown file.
• Bots can launch and monitor parallel worker sessions but cannot delegate tasks to other bots.
• Permissions are strictly scoped at creation, with bots requiring explicit approval to gain additional tools.
• Developers interact with bots through ongoing chat channels that serve as the primary interface for direction and feedback.
• The system is designed to prevent "context rot" by ensuring lessons learned in one session persist for future tasks.

Why it matters

For software teams building with AI, the shift from task delegation to process delegation represents a significant efficiency gain. Instead of spending hours copying context between short-lived agent interactions, engineers can define high-level goals and let bots handle the execution details. This reduces cognitive load and minimizes the risk of errors caused by incomplete or outdated information being passed between sessions.

The emphasis on scoped permissions and human-in-the-loop approvals also addresses critical safety concerns in autonomous coding. By ensuring that bots only have access to the tools necessary for their specific job, AWS reduces the blast radius of potential mistakes. This structured approach allows organizations to adopt agentic workflows with greater confidence, knowing that critical actions like deployments still require human verification.

Furthermore, the inability of bots to delegate to other bots simplifies debugging and accountability. When a problem arises, developers can trace it back to a specific bot’s logic and memory state without navigating a complex web of inter-agent dependencies. This clarity is essential for maintaining reliable software delivery pipelines as AI agents become more integrated into daily development workflows.

What you can do

• Open the Kiro Crew sidebar in your development environment to access the new bots workspace.
• Create a new bot and select either a default agent or a custom agent base with specific prompts and tools.
• Define strict permission scopes for each bot, limiting access to only the tools required for its specific task.
• Establish routine checks, such as having a bot investigate build failures overnight, to automate repetitive monitoring tasks.
• Regularly review and edit the bot’s memory markdown file to correct misunderstandings or update operational boundaries.
• Monitor bot performance through their dedicated chat channels, providing feedback to refine their behavior over time.