BatonBot: An Open-Source Kanban Tool for Managing AI Coding Agents

When AI Coding Meets Kanban Management

As AI coding assistants become increasingly widespread, more and more developers are exploring "vibe coding" — a concept introduced and popularized by OpenAI co-founder Andrej Karpathy in early 2025. The core idea is that developers describe their intent in natural language and leave the implementation details entirely to AI models, with developers taking on more of a "product manager" role rather than the traditional "programmer" who writes code line by line. The rise of this paradigm is closely tied to the maturation of tools like GitHub Copilot, Cursor, and Claude Code, and has given rise to new engineering challenges such as multi-turn conversation management and task context preservation. Yet one pain point that often gets overlooked in practice has become increasingly apparent: the orchestration and waiting costs of multi-agent tasks. Recently, a developer shared their open-source project BatonBot on Reddit — a local-first kanban tool designed specifically for running AI coding agents — offering a novel solution to this problem.

BatonBot's core concept is simple yet clever: bringing the familiar Kanban workflow into the AI agent management space. The Kanban method originated in Toyota's lean manufacturing system in the 1950s, systematized by Taiichi Ohno as a production management tool, with core principles including visualizing workflow, limiting work-in-progress (WIP limits), and managing flow efficiency. Around 2007, David Anderson introduced Kanban into software development, and modern tools like Trello, Jira Board, and Linear all center on this paradigm, making it the most familiar task management mental model for developers. BatonBot migrates this mature paradigm into AI agent management, leveraging developers' existing cognitive foundations to lower the learning curve. Each card corresponds to an independent agent session with its own working directory, logs, and history. This design allows developers to intuitively manage the running state of multiple AI agents, just as they would manage traditional project tasks.

A Product Philosophy Born from "Laziness"

The author openly admits that BatonBot was born from a simple motivation — "laziness." He loves using local models for coding, but local models tend to respond more slowly than cutting-edge cloud models. When he already knew what prompts he wanted to enter next, he was forced to sit and wait for the model to return results before manually pasting the next instruction — a repetitive wait that felt deeply inefficient.

"I usually already know what the next few prompts are going to be, but local models are slow, and I got tired of just sitting there waiting to paste the next prompt."

So BatonBot's initial core design goal was to automatically execute prompts in sequence. Users can pre-arrange a series of task instructions and then walk away to do other things while the agent completes the work in the background. This "set-and-forget" pattern essentially frees developers from passive waiting, allowing them to focus their attention on the parts that actually require decision-making.

Pipeline-Style Multi-Agent Collaboration

Building on automatic queuing, BatonBot further supports pipeline functionality. AI agent orchestration is one of the core engineering challenges in large model applications today, requiring solutions for context window management (how each agent's history stays intact without exceeding token limits), task dependency modeling (how the output of upstream agents serves as input for downstream agents), error propagation isolation (how to prevent a single agent failure from affecting the entire pipeline), and state persistence. Frameworks like LangChain, AutoGen, and CrewAI attempt to solve these problems at the code level, while BatonBot provides a more intuitive visual management interface at the UI/UX level — the two approaches are complementary. Developers can create multiple agents to handle the same task chain in sequence, forming an assembly-line-style collaboration — for example, the first agent writes code, the second runs tests, and the third fixes issues. This division of labor makes the decomposition and execution of complex tasks more organized, and keeps the responsibilities of each agent clearly defined.

Flexible Architecture and External Tool Integration

What began as a simple idea to solve a waiting problem ultimately evolved into a more extensible architecture. BatonBot is more than just a local prompt queue tool — it can also connect to external systems, most notably through its Jira integration.

Jira is an enterprise-level project tracking tool developed by Atlassian, with over 100,000 enterprise users and the de facto standard ticketing system in software engineering. Jira provides a robust REST API and Webhook mechanism that allows external systems to read and write ticket statuses, comments, and attachments. By integrating with Jira, BatonBot can receive task tickets directly and autonomously process them like an "AI colleague" — engineering teams don't need to change their existing task assignment processes, as AI agents can be assigned tickets just like regular team members and write execution results back to the system. This integration philosophy of "embedding AI into existing workflows" rather than "rebuilding workflows" helps reduce organizational resistance to AI automation adoption, and reflects the pragmatic approach in enterprise AI deployment where "system integration" takes priority over "platform replacement." This means a team's task assignment process can seamlessly connect with AI agent execution — tickets created in project management tools can flow directly to AI for execution. This design blurs the line between "human collaborators" and "AI collaborators," opening up new possibilities for team collaboration models.

Additionally, BatonBot supports routing different work to different agents while maintaining clear change logs for each: what it modified, what it tested, and where it failed. This traceability is critical for team collaboration and debugging, and also addresses a core trust issue in AI-automated programming — after AI completes a large amount of work, how can humans effectively verify and review its output.

Local-First and Model Flexibility

BatonBot is built on a local-first design principle. Local-First is a software design philosophy systematically articulated by the Ink & Switch research team in their 2019 paper "Local-first software: You own your data, in spite of the cloud," which advocates that application data should first be stored and processed on the user's local device, with cloud sync as an optional supplement rather than a required dependency. In the AI coding tool context, local-first has three practical implications: code security (enterprise codebases don't need to pass through third-party servers, avoiding intellectual property leakage), latency control (local model inference is unaffected by network fluctuations), and cost predictability (no API usage fees). With the proliferation of local model runtime frameworks like Ollama and LM Studio, the barrier to local-first AI tools has been significantly lowered — particularly friendly to developers who prioritize code security and data privacy. Code never needs to be uploaded to third-party servers, and the agent's runtime environment and data all remain local.

At the same time, the tool maintains high flexibility in model selection. Although the author personally prefers local models, BatonBot also supports mainstream cutting-edge cloud models. Developers can freely switch based on task complexity and response speed requirements: use local models for routine tasks to control costs, and use frontier models for complex scenarios — both can operate together within the same kanban workflow.

AI Coding: From Single Interactions to Task Orchestration

The emergence of BatonBot reflects an industry trend in AI-assisted programming, evolving from "single interactions" toward "task orchestration." Early AI coding assistants functioned more like instant Q&A tools, but as agent capabilities continue to grow, how to efficiently organize and schedule multiple agents and parallel tasks is becoming a new bottleneck in improving developer productivity.

Kanban, as a mature and intuitive visual management paradigm, couldn't be better timed for introduction into AI agent management. It makes the abstract state of agent execution visible and controllable, and allows developers to manage AI workflows using familiar mental models. As a relatively new tool, BatonBot still needs more users to test its value in real-world scenarios, but the direction itself is worth continued attention.

For developers looking to explore AI agent orchestration while valuing local deployment and open-source freedom, BatonBot is an experimental project well worth trying out hands-on.

Project repository: https://github.com/mdoty4/batonbot Official website: https://batonbot.com