Mastering Multi-Agent AI Workflows: Codex, Claude Code, and Hermes on a Unified Kanban Board

Overview

This course explores a tightly integrated AI‑agent workflow in which three specialized large‑language‑model agents—Codex, Claude Code, and Hermes—collaborate on a single Kanban board to take a software feature from idea to done without human intervention. By examining each agent’s role, the mechanics of handoff, and the Kanban‑based orchestration, learners will understand how to design, implement, and manage fully autonomous development pipelines. The material is valuable for engineers, tech leads, and AI enthusiasts who want to harness the latest generative‑model capabilities to eliminate bottlenecks in software delivery.

Background & Context

The rise of powerful code‑generation models such as OpenAI’s Codex and Anthropic’s Claude has shifted the paradigm from manual coding to AI‑assisted programming. Early adopters used these models as copilots, still requiring a human to trigger generation, review output, and merge changes. As model reliability improved, researchers began experimenting with chaining multiple agents together, letting each model specialize in a subtask—generation, review, or orchestration—while a shared state machine tracks progress.

Kanban, a lean workflow management method originating from Toyota’s production system, provides a visual, pull‑based system that limits work‑in‑progress and highlights bottlenecks. When combined with AI agents, a Kanban board becomes the single source of truth for task status, enabling agents to autonomously move cards across columns as they complete their designated steps.

The tweet that inspired this course highlights a practitioner who successfully wired Codex (code builder), Claude Code (code reviewer), and Hermes (orchestrator) onto one Kanban board, achieving a “nobody is waiting on a human” flow. This scenario exemplifies the cutting edge of multi‑agent systems where trust, handoff protocols, and visibility are engineered into the workflow rather than left to ad‑hoc human coordination. Understanding this pattern prepares learners to replicate or extend it for domains beyond software, such as data pipelines, content creation, or automated testing.

Core Concepts

Codex Builds It

Codex is a transformer‑based language model fine‑tuned on billions of lines of public source code. When given a natural‑language description of a desired function, class, or algorithm, Codex can synthesize syntactically correct and often semantically appropriate code in dozens of programming languages. In the workflow described, Codex receives a Kanban card that contains a user story or acceptance criteria; it then generates the implementation file(s) and commits them to a feature branch. The model’s strength lies in its ability to produce boilerplate, algorithmic scaffolding, and even unit‑test stubs quickly, reducing the cognitive load on human developers. However, raw Codex output may contain subtle bugs, style violations, or logical gaps, which is why a dedicated review agent follows.

Claude Code Reviews It

Claude Code refers to the use of Anthropic’s Claude family of models—particularly those aligned for code understanding and review—to examine the diff produced by Codex. Claude’s training emphasizes safety, reasoning, and the ability to follow complex instructions, making it adept at spotting style inconsistencies, potential security issues, missing error handling, and deviations from the specification. In the workflow, Claude Code receives the pull request generated by Codex, runs a review prompt that asks it to comment on correctness, readability, and test coverage, and then either approves the change or requests revisions with specific feedback. Because Claude can iterate on its own feedback, it can suggest concrete code edits that Codex can incorporate in a subsequent generation round, establishing a tight feedback loop.

Hermes Orchestrates the Handoff

Hermes is an orchestration agent—often implemented as a lightweight state machine or a rule‑based planner—that monitors the Kanban board, interprets the outcomes of Codex and Claude Code actions, and decides the next state transition for each task. When Codex finishes a build, Hermes moves the card from “Backlog” to “In Review”. When Claude Code approves the review, Hermes advances the card to “Ready for Merge” or directly to “Done” if continuous‑integration checks pass. Hermes can also trigger external actions such as running CI pipelines, updating issue trackers, or notifying stakeholders via Slack or email. Its orchestrator role ensures that no agent sits idle waiting for a human cue; instead, the flow is driven by deterministic rules derived from the team’s definition of done.

Three Agents Collaboration

The power of the three‑agent setup lies in role specialization and redundancy reduction. Codex focuses exclusively on synthesis, Claude Code on verification, and Hermes on coordination. By decoupling these concerns, each agent can be prompted with a narrow, well‑scoped instruction set, improving reliability and reducing hallucination. The agents communicate implicitly through the Kanban board’s card metadata (e.g., links to generated code, review comments, CI status) rather than via direct API calls, which simplifies debugging and auditability. This modularity also permits swapping one agent for another—e.g., replacing Codex with a newer code model—without redesigning the entire workflow.

One Kanban Board

A single Kanban board serves as the shared workspace and source of truth. Typical columns might include: Backlog → Ready → In Build (Codex) → In Review (Claude Code) → Waiting for CI → Done. Each card carries essential fields: title, description, assignee (the agent responsible), links to generated artifacts, and a checklist of definition‑of‑done items. Because the board is visible to both agents and any human overseers, it provides transparency: a manager can glance at the board to see how many items are stuck in review, which agents are most active, and where latency arises. The board’s pull‑based nature ensures that agents only start new work when capacity exists, preventing overload and maintaining a steady flow.

Nobody Is Waiting on a Human

The ultimate goal of this configuration is to eliminate human‑in‑the‑loop delays for routine, well‑specified tasks. When the agents are correctly configured, a feature can move from idea to production solely through agent actions: Codex writes code, Claude Code validates it, Hermes enforces the process, and CI/CD pipelines run automated tests. Humans remain involved only for higher‑level activities such as backlog grooming, priority setting, handling exceptions, or reviewing novel architectural decisions. This shift frees engineers to focus on creative problem‑solving while the agents handle repetitive, predictable work.

How It Works / Step‑by‑Step

1. Backlog Grooming (Human) – A product owner writes a user story and places it in the “Backlog” column of the Kanban board, adding acceptance criteria and any relevant design notes.
2. Trigger Build – Hermes polls the board for cards in “Backlog” whose “Ready” flag is set (or whose priority exceeds a threshold). Upon detection, Hermes updates the card’s assignee to “Codex” and moves it to “In Build”.
3. Code Generation – Codex receives the card’s description via a prompt such as:

```

You are an expert software engineer. Write a Python function that implements the following specification:

{{card.description}}

Follow PEP 8, include type hints, and add a docstring.

```

Codex returns the generated code, which Hermes commits to a new feature branch and links to the card.

1. Move to Review – Hermes changes the column to “In Review” and sets the assignee to “Claude Code”.
2. Code Review Prompt – Claude Code receives a prompt that includes the diff and the original specification:

```

Review the following code change against the specification:

{{spec}}

Diff:

{{diff}}

Comment on correctness, style, security, and test coverage. If issues are found, suggest concrete edits.

```

Claude Code outputs review comments, which Hermes posts as comments on the pull request associated with the card.

1. Iterative Fix Loop – If Claude Code requests changes, Hermes moves the card back to “In Build”, updates the Codex prompt to include the review feedback, and repeats steps 3‑5. This loop continues until Claude Code returns an approval comment (e.g., “LGTM”).
2. CI Validation – Upon approval, Hermes triggers the continuous‑integration pipeline (e.g., GitHub Actions) to run unit tests, linting, and security scans. The card moves to “Waiting for CI”.
3. Completion – When CI passes, Hermes moves the card to “Done”, updates any linked issue trackers, and optionally notifies stakeholders via Slack or email.
4. Board Maintenance – Humans periodically review the board for stalled cards, adjust WIP limits, and refine prompts based on observed failure modes.

Real‑World Examples & Use Cases

Example 1: Internal Tooling Sprint

A mid‑size tech company maintains a library of internal CLI tools. Each sprint, engineers create small utility commands (e.g., a CSV‑to‑JSON converter). Using the three‑agent Kanban workflow:

• Product managers write a one‑sentence description (“Convert CSV files to JSON with optional column filtering”).
• Codex generates the Python script with argparse and pandas.
• Claude Code checks for proper error handling, validates that the script works with large files, and ensures the MIT license header is present.
• Hermes runs the script through a pre‑commit CI that executes a few sample conversions and checks output format.

The entire process, from idea to merged PR, completes in under 15 minutes with no human developer touching the code.

Example 2: Open‑Source Bug‑Fix Automation

An open‑source project receives a bug report describing an off‑by‑one error in a parsing function. The triage bot creates a Kanban card in the “Backlog” with the bug description and a link to the failing test.

• Codex writes a fix that adjusts the loop boundary.
• Claude Code reviews the fix, confirms that the existing test suite passes, and adds a comment suggesting an additional edge‑case test.
• Hermes adds the suggested test to the pull request, triggers CI, and moves the card to “Done” once all checks pass.

Maintainers only need to approve the final merge, drastically reducing turnaround time for trivial bugs.

Example 3: Content Generation Pipeline

A marketing team wants to produce weekly blog post outlines based on trending keywords.

• A content strategist places a card with the keyword and desired length in the Backlog.
• Codex generates a structured outline (headings, bullet points, suggested word count).
• Claude Code (repurposed for text review) checks the outline for coherence, relevance to the keyword, and adherence to brand voice.
• Hermes moves the card to “Ready for Writing”, where a human writer fleshes out the full article.

Here the agents handle the ideation and structural review, leaving the creative writing to humans while still accelerating the overall pipeline.

Key Insights & Takeaways

• Specializing agents (generation, review, orchestration) increases reliability compared to a single monolithic model.
• A Kanban board provides a transparent, pull‑based state machine that enables agents to autonomously advance work without human prompts.
• Iterative feedback loops between Codex and Claude Code can converge on correct code faster than a single generation attempt, especially when review prompts are explicit about desired fixes.
• Orchestration agents like Hermes must be equipped with deterministic rules (e.g., move to next column only after CI success) to prevent agents from getting stuck in loops.
• Human involvement shifts from low‑level task execution to higher‑level activities such as backlog prioritization, exception handling, and prompt engineering.
• The workflow scales horizontally: multiple cards can be processed in parallel, limited only by the board’s WIP limits and the agents’ throughput.
• Integrating automated testing and linting as part of Hermes’s handoff criteria ensures that “Done” truly means shippable quality.
• The approach is language‑agnostic; swapping Codex for a model specialized in another language (e.g., JavaScript/TypeScript) requires only a prompt change.
• Monitoring metrics such as average cycle time, percent of cards requiring human rework, and agent token usage helps continuously tune the system.
• Ethical considerations remain: agents may propagate biases present in training data, so periodic human audits of generated code are still advisable.

Common Pitfalls / What to Watch Out For

• Over‑reliance on Agent Output – Assuming Codex’s code is always correct can introduce subtle bugs; always enforce a review step and CI validation.
• Poor Prompt Design – Vague or ambiguous prompts lead to irrelevant or hallucinated code; invest time in crafting precise, structured prompts with examples.
• Insufficient WIP Limits – Allowing too many cards in “In Build” can cause token‑rate throttling and increased latency; enforce strict limits based on agent capacity.
• Ignoring Model Drift – Updates to the underlying models may change behavior; maintain version‑controlled prompts and regression test suites.
• Neglecting Edge Cases – Claude Code may miss domain‑specific security patterns; supplement AI review with static analysis tools and manual threat modeling for critical code.
• Orchestrator Complexity – Over‑engineering Hermes with complex AI decision‑making can reintroduce uncertainty; keep its logic rule‑based and observable.
• Lack of Observability – Without logging of agent prompts, responses, and board transitions, debugging failures becomes opaque; integrate tracing and metrics collection.
• Human Bottleneck in Escalation – If exceptions frequently require human judgment, the flow stalls; define clear escalation paths and threshold criteria for when a card should be pulled for human review.

Review Questions

1. Explain how the specialization of Codex (builder) and Claude Code (reviewer) reduces the likelihood of hallucinated or incorrect code compared to using a single model for both tasks.
2. Describe the role of Hermes in the workflow, detailing at least three distinct actions it performs based on the state of a Kanban card.
3. Imagine a scenario where the CI pipeline consistently fails after Claude Code approves a change. Propose two concrete modifications to the workflow (e.g., prompt adjustments, orchestrator rules, or additional agent roles) that would help resolve the recurring failures.

Further Learning

• Study multi‑agent frameworks such as AutoGen, LangChain Agents, and MetaGPT to see how similar role‑based orchestration is implemented at scale.
• Explore advanced prompt‑engineering techniques (chain‑of‑thought, self‑consistency, few‑shot examples) to improve the reliability of Codex and Claude Code outputs.
• Investigate Kanban‑tool APIs (e.g., Trello, Jira, Azure Boards) to automate card movement via webhooks or custom scripts, enabling tighter integration with Hermes.
• Learn about continuous‑integration best practices for AI‑generated code, including test‑generation with models like CodeT5 or StarCoder.
• Read research on human‑in‑the‑loop vs fully autonomous systems in software engineering to understand when human oversight remains essential.
• Experiment with swapping in alternative code models (e.g., StarCoder, CodeLlama, WizardCoder) and evaluating their impact on cycle time and defect rates.
• Delve into observability for LLM pipelines: logging prompts, token usage, latency, and failure modes using tools like LangSmith, Weights & Biases, or custom ELK stacks.
• Consider ethical AI guidelines for code generation, focusing on bias detection, license compliance, and security vulnerability scanning.

<!-- auto-diagram -->

flowchart LR
    A[Idea] --> B[Codex: Generate Code]
    B --> C[Claude Code: Review & Refine]
    C --> D[Hermes: Orchestrate & Update Kanban]
    D --> E[Kanban Board: Track WIP]
    E --> F[Done]