Relay

Inspiration

Long AI coding sessions can become expensive, fragile, and hard to trust. Context grows, interrupted work gets repeated, and agents may claim success without independent proof.

Relay was inspired by a simple idea: plan once, split the work into durable tasks, route each task to the right model, and integrate only verified results.

What it does

Relay turns one complex coding request into a controlled multi-agent workflow.

Sol creates the plan. Terra handles the main implementation. Luna handles bounded testing and documentation tasks. Relay’s controller validates, commits, integrates, records evidence, and cleans up.

Workers run in isolated Git worktrees and cannot approve or merge their own work. Active tasks remain recoverable on disk, while completed tasks are compacted into PLAN.md.

How we built it

Relay was built as a TypeScript runtime, CLI, Codex plugin, and local dashboard.

We developed it through one primary Codex thread using strict milestones, offline tests, and limited live attempts. The final release supports:

durable planning;

isolated worktrees;
parallel execution;
deterministic integration;
controller-owned validation;
evidence export;
replay, local, and live modes;
an installable Linux package. ## Challenges we ran into The biggest challenges were separating model authority from controller authority, working with restricted Git environments, and fixing validator false positives.

Several valid implementations were initially rejected because the validators depended too much on wording or source-code structure. We corrected this by verifying behavior directly and using source analysis only as supporting evidence.

Accomplishments that we're proud of

The final packaged live run completed successfully with:

one Sol planning task;
one Terra implementation task;
two parallel Luna tasks;
three controller-owned commits;
three integrations;
three evidence bundles;
a final directory containing only PLAN.md.

We also built a working CLI, Codex plugin, dashboard, replay mode, deterministic demo, and judge-ready release package.

In a controlled benchmark, both mixed-tier and all-Sol strategies passed the same acceptance suite. The mixed-tier workers used an estimated 14.66 Codex credits, compared with 36.03 for all-Sol—a 59.31% difference in that benchmark.

What we learned

Reliable agent orchestration depends less on adding more agents and more on controlling authority.

Workers should propose changes, but the controller should independently prove that those changes are safe and correct.

We also learned that durable plans and task packets can provide better recovery than preserving an entire conversation, and that parallel execution still needs deterministic integration.