Aming Claw

Aming Claw turns Codex into a governed worker: it verifies where the agent is, pushes the next legal action, and records evidence so long-running coding work stays on track.

Comment

Inspiration

Long-running coding agents rarely fail because they cannot write code. They fail because they lose their position.

I watched capable agents complete many locally correct steps while gradually forgetting which phase they were in, which evidence had been accepted, and which action was legal next. In one case, an adversarial QA agent produced nine valid rejections while product progress remained frozen for 27 hours.

That led to a simple model:

[ P(\text{correct step}) = P(\text{correct position}) \times P(\text{correct entrance} \mid \text{position}) ]

Giving an agent more context does not make either variable certain. A drifting agent is still being asked to retrieve the right context, reconstruct its own position, and choose among multiple possible entrances.

I built Aming Claw around the opposite model: push, not pull.

What it does

Aming Claw is a local-first governance runtime for Codex and other coding agents.

Before an agent acts, the runtime pushes:

  • its current role and contract;
  • verified project and task position;
  • the next legal action;
  • allowed and blocked operations;
  • required evidence;
  • the gate that will verify completion.

The system combines:

  • a commit-bound project graph for codebase facts;
  • contracts that turn plans into checkable rules;
  • durable backlog and timeline state;
  • independent worker and QA identities;
  • direct, parallel, and batch execution paths;
  • a dashboard for human oversight.

The agent still reasons and writes code. It no longer has to reconstruct “Where am I, what role am I playing, and what is legal next?” from chat memory.

What I built during OpenAI Build Week

Aming Claw existed before Build Week. This submission focuses on the meaningful extension built with Codex and GPT-5.6 during the submission period.

I used Codex to:

  • make ContractRuntime the canonical authority for current task state;
  • expose that authority through a coherent dashboard read model;
  • add a typed backlog and contract DAG while redacting private runtime data;
  • separate live current state from historical timeline playback;
  • stream and invalidate current runtime projections correctly;
  • harden direct, bounded-parallel, and batch integration paths;
  • preserve QA identity, evidence provenance, and candidate lineage across retries;
  • add restart-safe batch integration epochs and ordered merge behavior;
  • diagnose blockers, implement repairs, run tests, and verify the resulting flows.

The dated Git history and submitted Codex session distinguish this Build Week work from the pre-existing project.

How I built it

The governance runtime and MCP server are written in Python. Project relationships are represented with NetworkX, durable local state uses SQLite and append-only timeline records, and Git commits bind runtime claims to exact code states.

The human-oversight dashboard uses React, TypeScript, and Vite.

Codex with GPT-5.6 acted as an implementation participant inside the system it was helping build. Work was assigned through governed contracts, changes produced evidence, separate QA contexts challenged the results, and failures were returned through explicit recovery paths.

This made the project a dogfood experiment: the tool was governing its own development while being repaired and extended.

Challenges

The hardest problem was not generating code. It was preserving one authoritative position across workers, QA, merge queues, graph snapshots, runtime state, and the dashboard.

Parallel implementation also becomes serial at shared-state boundaries. Branches may develop independently, but merge, reconcile, redeploy, and close must remain ordered.

A second challenge was preventing review itself from drifting. An adversarial reviewer can keep finding valid issues forever if the acceptance baseline silently moves. Aming Claw therefore freezes the current verdict criteria and records new discoveries as later work instead of changing the active finish line.

Accomplishments

  • A working local governance runtime accessible through MCP.
  • A commit-bound graph and durable evidence

Built With

Share this project:

Updates

posted an update —

A three-day agent loop changed Aming Claw’s control model

While developing Aming Claw, our governance runtime entered a three-day recursive orbit.

It created 102 work items. By item count, 68% were repair, diagnostic, or recovery work. Repairs merged, tests passed, and every aggregate gauge stayed green.

The surprising part: the router was not guessing. At every step, it exposed exactly one legal next action.

The entrance was right. The position was stale.

A repair changed the world, but an older generation—together with its evidence and evaluation authority—was allowed back into the active lifecycle.

That exposed a missing control contract: a verified position needs a coordinate, a frozen datum, and a live warranty.

The design rule we took forward:

  • Freeze the success predicate within a generation.
  • Expire its warranty when a material change creates the next generation.
  • Keep old evidence as history—never as current authority.

I documented the complete failure trace and the resulting theory extension here:

The Agent Industry Made Stack Overflow Billable

I’d welcome comparisons with how other agent runtimes certify semantic completion.

Log in or sign up for Devpost to join the conversation.