Noureddine RAMDI / Kodo: orchestrating AI coding agents with a plain API orchestrator for better autonomous development

Created Sat, 23 May 2026 20:41:14 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
1046 Words
github-stars python ai-coding multi-agent orchestration automation software-engineering

ikamensh/kodo

Kodo takes a different path in orchestrating AI coding agents by using a plain API model rather than CLI-based coding tools to coordinate multiple specialized agents. This design insight addresses a subtle but important problem: CLI coding tools tend to micromanage or attempt to write code themselves instead of purely delegating tasks. By keeping the orchestrator focused on high-level delegation via an API, Kodo enables more efficient multi-agent collaboration that yields measurable improvements in autonomous coding accuracy.

What Kodo does and how it’s built

Kodo is a Python-based orchestration layer designed to coordinate multiple AI coding agents — including Claude Code, Cursor, Codex, and Gemini CLI. Unlike many AI coding assistants that operate solo, Kodo manages a team of agents working in parallel and in structured work cycles.

The architecture revolves around a plain API model called Gemini Flash, which serves as the orchestrator. This orchestrator does not write code itself but delegates work to specialized agents. These agents fulfill different roles: some act as smart workers or architects (like Claude Code), while others serve as fast workers or testers (Cursor, Codex, Gemini CLI). This division of labor allows for an independent verification process — an architect reviews code for bugs, while testers validate functionality before accepting the work.

Under the hood, Kodo supports interactive and non-interactive modes, checkpoint-based resumption for long-running processes, and dedicated workflows for testing, improving, and fixing code. The coordination is built around the insight that CLI agents often try to micromanage or produce code themselves, which can lead to inefficiencies. The plain API orchestrator stays in its lane, focusing on delegation and high-level management closer to human user behavior.

Technically, Kodo is Python-based and uses the uv tool for installation and dependency management. It requires configuring at least one agent backend, with Claude Code plus a fast backend (Cursor, Codex, or Gemini CLI) recommended for best results. API keys for orchestrators (Google API key for Gemini or Anthropic API key for Claude) are set in environment variables to enable the orchestrator’s functionality.

Technical strengths and design tradeoffs

Kodo’s key technical strength lies in its orchestration strategy. By separating coordination from code generation and using a plain API model instead of CLI-based coding tools, it avoids the common pitfall where agents try to do too much themselves. This results in more reliable delegation, clearer separation of concerns, and ultimately better autonomous development outcomes.

The independent verification workflow is another strong point: having a dedicated architect and testers creates a quality control loop that many single-agent systems lack. This mirrors human software engineering practices where peer review and testing are essential.

Benchmarking on SWE-bench shows Kodo achieving 57% verified accuracy compared to Cursor’s 46%, which translates to a 24% improvement in solving real-world GitHub issues using the same underlying model and prompt. This is a concrete demonstration that orchestration, even without switching models, can yield substantial gains.

However, the tradeoff is increased complexity in setup and maintenance. Kodo requires multiple agent backends to be installed and authenticated correctly, which can be a barrier for quick experimentation. The coordination logic also adds overhead and depends on reliable API keys and environment configuration.

From a code quality perspective, the project is straightforward Python with clear roles for orchestrator and agents. The use of checkpointing and modular workflows shows attention to robustness and practical autonomous operation. Still, it’s not a turnkey solution — users need familiarity with AI agent backends and environment management.

Quick start

The README provides a clear installation path using the uv tool, which manages Python tools and dependencies efficiently.

# Install uv (skip if already installed)
# Linux / macOS:
curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows (PowerShell):
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# Install kodo using uv
uv tool install git+https://github.com/ikamensh/kodo

# To install the SWE-bench benchmark harness (optional):
uv tool install --with 'kodo[benchmark]' git+https://github.com/ikamensh/kodo

After installation, ensure you have at least one agent backend installed and configured. Claude Code plus a fast backend like Cursor or Codex is recommended. The detailed setup instructions for these backends are in the repository docs.

Set your API keys in your environment or .env file:

GOOGLE_API_KEY=...     # For Gemini orchestrator (recommended)
ANTHROPIC_API_KEY=...  # For Claude API orchestrator (alternative)

This setup enables the plain API orchestrator mode, which is the preferred way to run Kodo.

verdict

Kodo is well-suited for developers and teams exploring autonomous AI coding workflows who want to coordinate multiple specialized agents reliably. It shines by separating orchestration from code generation and introducing independent verification stages that improve output quality.

While it requires some upfront effort to configure multiple agent backends and environment variables, the 24% accuracy improvement on SWE-bench versus single-agent setups is a strong argument for the orchestration approach.

The system’s design acknowledges the limitations of CLI coding tools as orchestrators and opts for a more disciplined API-driven coordination model. This makes Kodo worth understanding for practitioners working at the intersection of AI and software development automation.

If your use case involves experimenting with multi-agent AI coding or building autonomous development pipelines, Kodo offers a concrete, tested framework to build on. However, it is not a plug-and-play black box — expect to invest time in setup, backend configuration, and understanding the agent roles.

Overall, Kodo is a solid example of how orchestration strategy and architectural insight can improve AI coding agents’ practical utility beyond just switching underlying models.

→ GitHub Repo: ikamensh/kodo ⭐ 101 · Python