Introducing conductor mode in Kiro Crew
A conductor agent supervising worker agents through a ledger
Illustrative browser usage workflow: you give the conductor a goal. It coordinates interface, browser-control, test, and flow-check tasks through the work ledger, and every report is appended to a crew log. The report cells are illustrative, not live task results.
As the engineering team for Kiro Crew, working with AI agents lets us develop different parts of a feature in parallel. We start with a plan, then refine the requirements as we review prototypes and test the experience. Recently we have been developing a new feature to add the ability for an agent to drive a browser window, which we’ll refer to as browser usage. Those refinements during our own testing expanded its capabilities to include more browser controls, a live view in chat, and a testing function for finished work.
The work was spread across multiple chat sessions, along with all the context behind any changes made in each one as we built. That separation became a problem when we wanted to add more complex capabilities. We needed the context and updates happening in other chats, and we were left coordinating between them to bring that direction along.
For example, while playing with browser usage in real time, we wanted the ability to take over from the agent while it was working. For that to be useful, we had to watch the agent work, take control when needed, and then hand the browser back afterward. That meant adding a takeover button to the interface, pulling in context from the session that built the browser interface, and pulling in context from the session that wrote the agent loop so the agent would pause and the full interaction could be checked. We had to remember where decisions touching the new capability had happened, carry the context between sessions, and then confirm that everything fit together.
That separation is what shaped conductor mode in Kiro Crew. For the browser usage feature, we started out doing all the coordination work ourselves. It was a short-term project that didn’t justify the setup of a Kiro bot we’d never use again. Instead of rebuilding the picture across each chat session, we built something that could take a goal we defined and, on its own, break out the various tasks needed to meet that goal, coordinate across each task with centralized context for any changes in direction, review the results against the goal with all that context, and report on the progress on one board that was easy for us to check.
Now, to build the takeover capability, we could just describe it to the conductor agent, and it would have all the context behind the other tasks building out the prototype, browser interface, and testing to know where within each part there needed to be additional work. We still decide how the feature should work, conductor mode handles all the coordination of the work, and we adjust as needed in a single chat with one board to see overall progress and any pending items needing our review.
Conductor mode adds a middle ground between an isolated chat session for a single focused task, and a Kiro bot that takes on a continuing responsibility without a deadline. Conductor mode can delegate to worker agents like bots can, but it is driven by your default Kiro Crew agent and global memory to complete a goal you hand over, instead of a recurring job to keep looking after.
A decision tree. Start at new work. If the work is recurring or never-ending, choose a bot, which owns it for weeks. Otherwise, if the work splits into items that can run in parallel, choose conductor mode, which coordinates worker agents. If it does not split, choose a chat for one focused task.
Recurring or never-ending?Splits into items that can run in parallel?yesnoyesnoWe tested conductor mode on our own work while we built it, and improved it each time something broke. In one run, we gave a conductor agent a queue of open tickets on our own repositories and one rule, never write code itself. It coordinated tasks across worker agents, read their reports, and checked their results.
The same run showed where the conductor agent’s judgment needed a fix. In one case, a worker agent’s pull request had failing checks. The conductor agent looked at the main branch, saw no failing checks there, and told the worker agent the failures came from its own changes. But the main branch didn’t run the same tests that were causing the failing checks, so seeing no failures there didn’t mean they were passing. Later the conductor agent saw the same failures on other pull requests, found a fix that was already merged to main, and corrected its earlier judgment. The worker agent hadn’t acted on the wrong call. It had waited for the fix and rebased.
The run also showed which decisions belong to a person. On another ticket, the only quick fix would have let every scheduled script that hadn’t been approved read cached credentials. The conductor agent didn’t make that change. It wrote up the tradeoff, a quick fix against a weaker security boundary, and sent it to a person to review. Loosening a security boundary isn’t a decision we want a conductor agent making, and we keep the control to make sure those boundaries stay enforced.
Running the conductor agent on real work showed us what didn’t hold up, and these are the key design decisions we made in response. For each one, we translated the problem we saw into what conductor mode does now.
At first, we let the conductor agent make small fixes itself. Each time it did, it spent that turn on the fix, and its checks on the other worker agents got worse. So, the default conductor agent has no direct file-editing tool and delegates all changes to worker agents.
At first, the conductor agent read worker agent transcripts to find out what happened. That didn’t scale, and “I think this is mostly done” is not a status. Now each worker agent is tied to one task and reports with work_report as progress, done, blocked, or question, with a link to evidence such as a pull request. The conductor agent reads the whole board with a single work_ledger_read call.
An illustrative scenario. A new decision, pause on takeover, must reach the interface, browser-control, and test tasks. In the separate-sessions view, the button is present but clicking it does not pause the agent, while the browser controls and tests still follow the earlier requirement. In the coordinated-work view, the shared requirement guides the work and the check: the conductor updates all three briefs, so the button pauses the agent and the full flow is checked.
The button is present, but clicking it does not pause the agent
A conductor agent can run for days. Long chats get summarized, which can drop detail, and a new session needs the saved state to resume. During our runs, we saw the connection to the conductor agent’s tools dropped occasionally, interrupting its work. Instead of keeping the plan in the chat, we designed conductor mode to use an append-only crew log as the source of truth, with a work ledger that holds tasks and their results, and a session ledger that holds the goal, the next step, and the approaches already rejected. This way, each time the connection drops, the conductor agent can pick up again from that saved state without relying solely on summarized chats.
We designed conductor mode to run checks on worker agents to keep tasks on track and aligned to the overall goal beyond the initial kickoff. We like to refer to this as the conductor agent running a patrol check. At first, every patrol check was a model turn, including checks that found nothing new. To make checks more efficient, we adjusted so that a small piece of code reads the work ledger first and skips a model turn when nothing needs attention. When a worker agent reports done, blocked, or question, the next patrol check also moves up, so the conductor agent sees the report sooner.
At first, we asked the conductor agent to drop its own context at the end of each batch of work. That created a risk, because it left the reset dependent on the agent following the instruction. To address it, when a conductor mode session has grown long and been idle, Kiro Crew restarts its next turn in a fresh model session with the ledger snapshot and the latest messages, so the conductor agent can resume from its saved plan.
During our runs, we saw that fixes to our internal build stayed in draft until automated review had nothing valid left to say. Since the review had to finish before the task could be accepted, a worker agent saying “done” wasn’t enough. To check each result against its agreed completion condition, the conductor agent calls the procedure accept_eval, which checks evidence in code against the condition for that task, such as a pull request’s checks, a file that must exist, or a pending request for a person’s approval. If a task fails the check three times, the procedure tells the conductor agent to close it as rejected. For the browser usage feature, the condition could be that the agent stops acting after you click the takeover button.
Early on, the conductor agent’s instructions told it to start a patrol check after assigning a worker agent to a task. Nothing confirmed that it actually did this, and we saw some conductor agents skipped it as a result, leaving worker agents running without the conductor agent reading their reports to keep them on track. During our runs, worker agents made the same mistake with their own loops and sat idle on a failing check until the conductor agent woke them. To address this, assigning a worker agent now attempts to start a patrol check if none is running, and Kiro Crew flags it when one is missing. Patrol setup no longer relies solely on the conductor agent remembering to start it, and it also won’t override a patrol check we stopped ourselves.
These runs also showed us where coordination still needs work. There are some specific areas that stood out to us as next steps as we continue to improve conductor mode.
Efficiency between worker agents. Right now, worker agents can’t message each other directly, so those messages go through the conductor agent. Reducing that coordination overhead is an area for further work.
Optimizing context across resets. By default, a conductor agent can hold up to 32 open tasks. Available resources and any lower limit you set determine how many run at once. Kiro Crew now supports fresh-session recovery for the default conductor.
Cost-driven optimization. We can’t yet break a goal’s cost down by task, or separate the cost of coordinating from the cost of the work itself, so it’s hard to tell which part of a run is expensive.
Conductor mode is available in Kiro Crew. In a chat session, turn on the conductor mode switch in the composer, describe a goal you’d otherwise drive through several separate tasks, and define what a successful result looks like. The board shows progress and the questions that need you.
If your goal is an ongoing responsibility instead, like keeping CI healthy, create a Kiro bot. Bots hand their bigger jobs to worker agents through the same ledger, so what we describe here applies to them too, and our post Introducing bots in Kiro Crew covers how to set one up.
If you’re building your own conductor agent, the same lessons can be applied. Keep it from writing code itself. Have worker agents report in a structured record. Keep the plan and state outside the chat. Have code watch for changes and call the model only when something has changed. Enforce the rules that must always hold outside the agent’s instructions, and don’t count a result until something independent verifies it.
The conductor agent, its skills, and the design documents behind this post are open source in the Kiro Crew repository on GitHub. Start at kiro.dev/crew.