Inspiration
AI coding agents are powerful, but serious software work still needs more than one unconstrained chat. It needs clear roles, explicit handoffs, reproducible execution, failure handling, and a real human approval boundary. I built Codex Corp to make that operating model visible and runnable.
What it does
Codex Corp is a local agent operating system for assembling specialist software companies as visual workflows.
You can create a company graph manually or ask Byte, the Workflow Architect, to design one from an outcome. Each specialist node runs as an isolated Live Codex thread. A company companion lets the operator start work, inspect progress, answer questions, stop runs, and handle approvals without living inside the graph editor.
The Rust runtime owns the parts that should not depend on an agent's judgment: scheduling, retries, revision loops, checkpoints, persistence, process lifecycle, human approval gates, and terminal state. Runs produce inspectable events, usage, context, and verified release artifacts. The same runtime can also run headlessly and expose authenticated MCP tools over loopback HTTP or stdio.
There are no simulated agents, canned model results, or fake success paths. Models come from the live Codex model catalog. If Live Codex is unavailable, output is malformed, a timeout occurs, or verification fails, the run fails closed.
How I built it
The desktop app uses React, TypeScript, Vite, React Flow, and Tauri 2. Rust owns orchestration and persistence with SQLite. Codex app-server supplies the live agent threads, streaming events, model catalog, approvals, and dynamic tools. A local MCP server exposes workflow and run operations for headless use.
The frontend and Rust layers communicate through typed contracts. Deterministic validation checks graphs and completion criteria. Delivery verification compares approved and live artifacts, including content hashes, before a release node can succeed.
How Codex and GPT-5.6 were used
Codex was the engineering environment throughout Build Week. GPT-5.6 helped me trace the TypeScript/Rust/app-server boundaries, design mediator and workflow contracts, implement the desktop and headless runtimes, and review failure paths.
I used Codex repeatedly to test adversarial cases rather than only generate features: malformed agent messages, interrupted approvals, stale threads, timeouts, retry plateaus, persistence recovery, process ownership, artifact tampering, and release packaging. The important product decisions remained explicit and verifier-owned: Rust owns terminal state, approval is a real graph gate, and invalid specialist output cannot self-certify as a successful release.
Challenges
The hardest part was keeping the system honest across asynchronous boundaries. A UI can look complete while a background process is stuck; a compiled desktop binary can still point at the development server; a specialist can return plausible prose that does not satisfy its contract. Fixing those issues required tracing actual process and data lifecycles, failing closed, and testing recovery paths.
Accomplishments
- Live multi-specialist Codex execution with isolated threads
- Visual workflow authoring plus Byte-assisted company design
- Human approval and revision loops
- Deterministic graph and delivery validation
- Persistent runs, events, checkpoints, usage, and artifacts
- Authenticated local MCP server and headless runtime
- Native release pipeline for Windows, Linux, and macOS
- 289 frontend tests and 178 Rust tests passing for the v0.1 candidate
What's next
After the hackathon I want to complete native smoke testing on Linux and macOS, add signed installers, improve import/export and observability, and keep tightening the verifier boundary so larger agent teams remain understandable and recoverable.
Built With
- codex
- gpt-5.6
- mcp
- playwright
- react
- rust
- sqlite
- tauri
- typescript
- vite
- vitest