AI coding agents have become remarkably capable. Give them a well-defined task and tools such as Claude Code or Codex and they can analyse requirements, write code, run tests and implement entire features with surprisingly little human involvement, but something interesting happens when you ask them to keep going.

Rather than completing a single task, what if you want an AI agent to build an entire application? What if the project involves hundreds of tasks, multiple features, design decisions, testing, dependencies and several agents working simultaneously? Suddenly, the problem isn't just about writing code; it's about managing the work, and that's a very different challenge.

The humble checklist

One of the simplest and most popular approaches to managing AI coding agents is a file called backlog.md. It's exactly what it sounds like: a text file containing a list of things that need to be done. You instruct the agent to read the list, pick the next unfinished task, complete it, mark it as done and move on to the next one. It's surprisingly effective.

You can even ask the agents themselves to build a project backlog and then work through it, progressively building out an application without requiring constant prompting.

But there's a catch. A checklist doesn't really understand the project. It doesn't know whether one task depends on another, whether something has been properly tested, whether a design has been approved, or whether the work is actually ready to be considered complete. It also doesn't provide much visibility.

If you have several agents working on a project, how do you know who's doing what? Which features are finished? What's blocked? What has been tested? Where are the problems? You can ask the agents, of course, but that rather defeats the purpose of having them work autonomously, and this got us thinking.

What if we treated AI coding agents like members of a software delivery team, rather than simply giving them a list of instructions?

Introducing Agent Boards

Agent Boards is an open-source project we've developed to help manage software delivery performed by AI coding agents. The premise is straightforward. Instead of relying on individual text files and conversations to manage a project, we give agents a shared project management system. Think of something along the lines of Jira, Trello or Monday.com, but designed specifically for AI agents to use alongside human developers and project managers.

Agents can pick up tasks, understand their requirements, record progress, identify blockers and move work through a defined delivery process. Meanwhile, people can open a visual dashboard and see exactly what's happening.

The important distinction is that Agent Boards doesn't write the code itself. Claude Code, Codex and other coding agents continue doing what they're good at. Agent Boards provides the structure around their work.

From a task list to a managed delivery process

Most people working in software development are familiar with a Kanban board. Tasks move across columns representing their current status, providing a simple visual picture of what's happening.

Agent Boards uses the same idea, but unlike a conventional task board, the stages mean something to the agents.

Backlog → Define → Deliver → Integrate → Done

Before an agent starts building a feature, it needs to understand the requirements and establish a plan. Before work can be considered complete, it needs to be checked and reviewed, and before a feature is marked as finished, the system needs evidence that the completed work has been successfully integrated and verified. These are familiar practices in professional software development, but unaided autonomous agents struggle with this consistency.

Agent Boards helps enforce a defined Software Development Lifecycle (or SDLC). An agent can't simply declare something finished because it believes the task is complete, it needs to demonstrate that the agreed conditions have been met.

Letting agents manage their own workload

One of the more interesting possibilities is allowing multiple agents to work on the same project. Imagine you have three AI coding agents available. Rather than manually assigning tasks to each one, they can independently ask Agent Boards what work is ready. The system considers priorities, dependencies and which tasks are already being worked on. An agent claims a task, receives the relevant requirements and gets on with the job. When it's finished, it records the outcome and asks for another. If something is blocked, the agent records why and can move on to other available work.

This means agents can continue making progress without constantly needing someone to tell them what to do next. It also reduces the risk of two agents accidentally doing the same work or building features in the wrong order. Of course, this doesn't eliminate the need for human involvement, it simply means that human attention can be directed towards the decisions that actually need it.

Knowing what's really finished

One of the challenges with AI-generated software is that a task can appear complete without necessarily being ready for use. The agent will usually be more than willing to tell you everything's done, tested, ready for Production (without having done anything more than the development).

So the agent wrote the code, but did it actually test it? Did it introduce a problem somewhere else? Did it actually deliver what was requested? Was the final version reviewed, or was something changed afterwards?

Agent Boards introduces a more disciplined definition of completion. Each feature can have clear requirements and acceptance criteria. As work progresses, the agent records the evidence that those criteria have been satisfied. That evidence remains associated with the work, providing a history of what was done and how it was verified.

For people overseeing a project, this is particularly valuable. Instead of relying on an agent saying "I've finished", you can see what was delivered, what checks were performed and whether there are outstanding issues. The objective isn't to slow agents down with unnecessary bureaucracy. It's to make their output more reliable and easier to trust.

Design needs human judgement too

There's another area where we believe human oversight remains particularly important: visual design.

AI agents are increasingly capable of creating attractive user interfaces, but that doesn't necessarily mean they've created the interface you wanted. Anyone who has spent time iterating on AI-generated designs will recognise the problem. You ask for a particular visual direction, the agent produces something close, and several rounds of adjustments follow. Sometimes a subsequent change even undoes something you previously approved.

Agent Boards treats design as an explicit part of the delivery process. For example, when creating a new application, agents can be required to produce alternative visual concepts before development begins. A person selects the preferred direction, which becomes the basis for the design system and subsequent screens. Mockups can then be reviewed and approved before implementation. Once the interface has been built, agents can provide screenshots and recordings demonstrating how it looks and behaves. The aim is to avoid a situation where an AI agent decides for itself that the design is satisfactory.

Agents do the production work, while people retain control over important creative decisions.

A shared memory for the entire project

Another weakness of managing projects through AI conversations is that context becomes fragmented. Requirements might live in one conversation, architectural decisions in another, design references somewhere else, and the current task list in a Markdown file. As projects get larger, maintaining that context becomes increasingly difficult.

Agent Boards brings all of the project's elements together. Project briefs, requirements, design decisions, risks, issues and delivery progress can all be maintained as part of the same project. This gives agents a consistent reference point, even when different agents or different AI models are involved. It also provides something that's often missing from AI-assisted development: a record of why decisions were made, not just what was implemented.

For a person returning to a project after several days, that history can be just as important as the code itself.

Keeping people in the loop without making them the bottleneck

There's a balance to be struck with autonomous software development. If every action requires approval, you lose much of the productivity advantage. But if agents can make every decision independently, you risk losing control of the project. Agent Boards is designed around that distinction.

Routine work can progress autonomously, while important decisions can remain subject to human approval. A person might approve a design direction, resolve an ambiguous requirement, review a significant change or decide whether an exception is acceptable. The agents can then continue working within those boundaries and because everything is visible through the board, you don't need to interrupt agents constantly to understand what's happening. The goal is to move from supervising every individual action to overseeing the delivery of the project as a whole.

An open-source starting point

We've made Agent Boards available as an open-source project under the Apache 2.0 licence. The initial alpha is intended for local or self-hosted use, with a demonstration project included so people can explore how the workflow operates.

It's still early, and the current release isn't intended to be a public, multi-tenant service (yet), but the underlying idea is one I think will become increasingly relevant as AI coding agents develop. We're moving from a world where AI assists developers with individual tasks towards one where agents can take responsibility for substantial pieces of software delivery and that shift creates a new set of management challenges. How do we coordinate multiple agents? How do we maintain quality? How do we retain project knowledge? And how do we provide meaningful human oversight without sacrificing autonomy? These are not fundamentally new problems; software teams have been dealing with them for decades. What's new is that the people doing much of the work may no longer be people!

AI coding agents are becoming capable software developers. Now they need a way to work as a team.

Try out Agent Boards and tell us what you think.