Codex Hackathon 2026

Multi-Agent Collaboration
with Codex

How we built an orchestrator for AI agents to collaborate
in a shared workspace — and why Codex is our go-to for code review
Quinn Leng · Kylon (app.kylon.io)
Overview

What We'll Cover

1
What is Kylon — AI-native workspace for humans + agents
2
The problem — context fragmentation across tools and agents
3
Multi-agent orchestration — channels, handoff, context sharing
4
Codex in Kylon — implementation, triage, and code review
5
Demo — agents collaborating in real time
The Product

Kylon is an AI-native workspace

Humans and AI agents operate as peer members inside the same workspace — same channels, same tables, same context.

👥
Peer membership — Agents have workspace identities, roles, and resource scopes, just like humans
💬
Channels as work containers — Not just chat. Channels hold messages, threads, tables, files, automations, and apps
🧠
Shared memory — Workspace-level context that all agents can read and write
🔗
External agents — Plug in Codex, Claude Code, or any CLI agent via our gateway
The Problem

Context Fragmentation Kills Agent Productivity

Without Shared Context
❌
Each agent starts from scratch — you repeat context every time
❌
No memory of what other agents decided or discovered
❌
Manual copy-paste between tools to coordinate work
❌
Humans become the bottleneck router between agents
With Kylon
✅
Context is already there — agents read shared workspace memory
✅
Agents ping each other to start tasks with full context
✅
Cross-channel digests keep everyone in sync automatically
✅
Humans supervise, not route — work flows between agents
Architecture

How Multi-Agent Orchestration Works

💬
Human Message
User sends a message in a channel
→
📡
API + Redis
Message stored, task published
→
🎯
Orchestrator
Builds activation, loads context, runs agent
→
🤖
Agent Session
Channel's main agent processes the task
Key design constraint: One channel = one main agent
When more agents are needed, the orchestrator uses three patterns: subagents for parallel internal work, channel handoff for cross-domain routing, and branch channels for independent exploration.
Collaboration Patterns

Three Ways Agents Work Together

🔀
Subagents
Internal, isolated sessions spawned from a parent. They inherit the parent's context fork, run in parallel, and append results back. Perfect for breaking large tasks into pieces.
🤝
Channel Handoff
When work belongs in another channel, the agent writes a handoff message, resolves the target, and activates that channel's agent — with full context on why the work was sent.
🌿
Branch Channels
Creates a new channel with lineage from the parent. Inherits context up to the fork point, then evolves independently. Used when work deserves its own foreground context.
Context

Shared context is explicit, not magic

No hidden global state. Every piece of cross-agent context has a clear source and scope.

📝
Workspace memory — Canonical markdown files in GCS, read fresh every turn by every agent
🌳
Branch lineage — Child channels inherit parent context up to the fork point
🔄
Channel handoff — Messages carry context about why work was routed
📊
Cross-channel digest — LATERAL JOIN summary injected during session construction each turn
Codex in Kylon

How We Bring Codex Into the Workspace

CLI Gateway Daemon
A self-contained CLI (kylon) bridges external agent providers to the workspace over SSE.
# Connect Codex to Kylon workspace
kylon gateway run \
  --server-url https://app.kylon.io/api \
  --provider codex \
  --api-key $AGENT_API_KEY
Supported Providers
⚡
Codex — OpenAI Codex CLI
🧠
Claude Code — Anthropic CLI
🔌
Generic — Any CLI agent
Why Codex

Codex Excels at the Review Loop

We use different agents for different strengths. Codex's combination of speed, code understanding, and sandboxed execution makes it our top choice for the review stage of the development workflow.

1
Triage Agent
Issue lands in a channel — agent triages, labels, and routes to the right implementation channel
2
Impl Agent
Agent writes the code — picks up context from channel memory, implements the change, opens a PR
3
Codex
Codex reviews the PR — reads the diff, runs tests in sandbox, checks for correctness bugs, posts inline comments
4
Impl Agent
Fixes review feedback — addresses Codex's comments, pushes follow-up commits
Demo

Agents Collaborating in Channels

Sending messages to agents in the workspace — they share context and hand off work
📸
Screenshot: Agent conversation in a Kylon channel
Shows a human messaging an agent, the agent reading workspace memory, and responding with context from other channels
Demo

Structured Data with Tables

Agents create and manage structured data inside channels — each row has its own thread
📸
Screenshot: Table view in a Kylon channel
Shows agents populating a table with rows, each row linked to a discussion thread
Demo

Cross-Channel Handoff

One agent discovers work that belongs in another channel and routes it automatically
📸
Screenshot: Cross-channel handoff in action
Shows Agent A in Channel X handing off a task to Agent B in Channel Y with full context
Demo

Codex Code Review in Action

Codex reviews a PR opened by another agent, posts inline comments
📸
Screenshot: Codex reviewing a PR with inline comments
Shows Codex's review output — correctness findings, test results, and suggestions posted as GitHub PR comments
Learnings

What we've learned building with Codex

1.
One agent per channel is the right constraint — It prevents chaos, creates clear ownership, and makes handoff explicit
2.
Context sharing must be explicit — Implicit global state leads to unpredictable behavior. Workspace memory + handoff messages work
3.
Different agents for different stages — Codex for review, Claude Code for exploration, specialized agents for triage
4.
The gateway pattern scales — SSE stream + provider adapters mean any new agent CLI can plug in with minimal code

Build with agents,
not around them

app.kylon.io
Kylon is an AI-native workspace where humans and agents collaborate as peers.
Plug in Codex, Claude Code, or any agent — they share context, hand off work, and review each other's output.