TaskBox — Human-Gated AI Coding Runtime

A bounded, auditable runtime that reproduces failures, applies one allowlisted change, validates results, writes machine-readable proof, and stops at a Human Gate.

Comment

Inspiration

AI coding tools can generate working changes quickly, but teams still need clear answers to basic operational questions: What source was read? What was allowed to change? Which commands actually ran? What remains under human control?

TaskBox was built to make one AI coding task bounded, reproducible, and auditable.

What it does

TaskBox turns one narrowly scoped coding request into a deterministic execution flow:

  1. Read and hash the source tree.
  2. Create a disposable working copy.
  3. Reproduce the failing baseline.
  4. Apply exactly one allowlisted change.
  5. Reject changes outside the approved path.
  6. Rerun validation.
  7. Write machine-readable JSON proof.
  8. Stop at a Human Gate.

The included public-safe demo starts with a missing filterTasks function. The baseline test exits with code 1. TaskBox then changes only src/tasks.mjs, reruns the tests, and produces six passing tests with a PASS_ADOPTABLE verdict.

The Human Gate controls handoff state only. It cannot stage, commit, push, publish, write a database, apply a source, or activate a runtime.

How we built it

GPT-5.6 narrowed a larger AI operating-system project into one independently useful developer tool and defined the product scope, acceptance criteria, and authority boundary.

Codex with GPT-5.6 Terra High implemented the majority of the core runtime in one primary build session, including:

  • deterministic task runner;
  • synthetic Node.js fixture;
  • file allowlist enforcement;
  • source and tree hashing;
  • machine-readable proof;
  • local web interface and API;
  • Human Gate state;
  • automated tests;
  • judge instructions.

TaskBox uses Python, JavaScript, Node.js built-in tests, HTML, CSS, JSON, Git, and GitHub. It requires no database, API key, or third-party runtime service.

Challenges

The main challenge was keeping the demo small while preserving real governance behavior. A working code change alone was not enough. The tool also needed to prove the baseline failure, constrain the exact changed path, preserve source hashes, expose command output, and keep external authority actions disabled.

Accomplishments

  • One complete end-to-end developer tool.
  • Reproducible failing and passing test states.
  • Exact changed-path enforcement.
  • Machine-readable proof packet.
  • Public-safe synthetic fixture.
  • Cross-platform local execution.
  • Public repository and under-three-minute demo.

What we learned

Reliable AI coding requires more than prompting. It needs explicit boundaries, validation, proof, and a visible Human Gate. Small deterministic execution boxes are easier to trust, test, review, and reuse than open-ended agent runs.

What's next

The next step is to generalize TaskBox into reusable task templates, richer validators, and adapters for additional coding environments while preserving the same human-controlled authority model.

Built With

Share this project:

Updates