Architect

Inspiration

AI coding agents are becoming capable of building real software, but they can still confidently claim a task is complete when the implementation is incomplete, unsafe, or outside the original intent.

Architect was built to solve that trust problem.

What it does

Architect turns Codex into a governed software production system.

A user defines one mission. Architect locks the intent, compiles bounded task packs, launches multiple Codex workers, records their execution, and treats every worker completion claim as untrusted until it is validated.

A process-separated evaluator called Wraith tests the result using presealed validation evidence.

If Wraith finds a hidden failure, Architect returns FALSE_SEAL, classifies the defect, unlocks only the responsible scope, permits one bounded repair, and revalidates the result.

The final output includes:

Real Codex execution receipts
Worker claims and changed files
Wraith evaluation evidence
Failure and repair history
A Sovereign Seal
An inspectable evidence graph
Deterministic replay

The core idea is simple:

AI agents can say they finished. Architect proves whether they did.

How we built it

Architect is a Windows desktop developer tool built with Go, Wails, React, TypeScript, PowerShell, Codex CLI, SRXML task contracts, and local evidence artifacts.

The Build Week release added and qualified:

Portable same-PC Codex execution
Three fixed Codex worker cells
Immutable mission and authority contracts
Process-separated Wraith evaluation
Presealed private validation
Real false-completion detection
One bounded repair path
Evidence hashing and receipt verification
Replay and safe termination
Judge Mode
Portable release packaging

Architect was also used to help build and qualify Architect itself.

Challenges

The hardest challenge was making the proof portable and truthful.

The first candidate worked inside the development repository but failed during a hostile clean-package judgment because release assets and runtime paths still depended on the original machine layout.

That failure was preserved rather than hidden.

The next candidate repaired the portable runtime root, packaged all required evaluator assets, removed hard-coded repository assumptions, added clearer diagnostics, corrected evidence generation, and completed two clean qualifications from the extracted desktop application.

Accomplishments

The final candidate completed:

Two clean Sovereign qualification runs
Eight current Codex thread executions
Three real worker cells per qualification
A real Wraith FALSE_SEAL
One scoped repair
Successful Wraith revalidation
Replay verification
Working baseline fallback
Clean extraction and launch
Portable Windows release
Zero operator code repairs during qualification

What we learned

Generating code is becoming easier.

Determining whether autonomous work deserves to be trusted is becoming the harder and more valuable problem.

Reliable agent systems need separation between:

Human intent
Execution authority
Evaluation authority
Repair authority
Final judgment

What's next

The current Build Week release uses process and repository boundaries on one Windows PC.

Future development will add stronger host-level isolation, broader repository support, additional model runtimes, enterprise policy controls, and team-based evidence review.

Architect’s long-term goal is to become the control and proof layer for agent-built software.

One intent. Many builders. One proven champion.