AgentLoop

Self-improving fresh-context agent loops on your machine. ChatGPT plans, fresh Codex workers build, a critic enforces your rubric every cycle. Less babysitting. More building.

Comment

Inspiration

I was running coding agents by hand: plan in ChatGPT, paste into Codex, paste results back, repeat. I was the relay between the planner and the executor, and quality slipped the moment I stopped watching. I wanted the handoff automated and my standards enforced without me in the middle.

What it does

AgentLoop is a local orchestration daemon for coding agents. It is built for solo developers running long Codex tasks without babysitting every session. You plan a goal in ChatGPT, and a custom MCP connector sends it to a daemon on your machine. Each cycle starts a fresh Codex worker with a clean context. Work carries forward in project files, not chat history. After every worker, a fresh critic grades the result against your rubric in GUIDELINES.md and turns failures into concrete fix notes for the next worker. Every worker and critic uses workspace-write sandboxing, disables network access inside the sandbox, and routes boundary requests through automatic approval review. Polish mode keeps improving past the first PASS until the critic verdicts SHIP. The whole run is watchable and cancellable on a local dashboard.

How I built it

The architecture and product decisions are mine: the sequential fresh-context design, the files-as-memory model, the strict critic verdict contract, the rubric-as-GUIDELINES pattern, and the scope calls on what shipped versus what stayed on the roadmap. Codex CLI with GPT-5.6 turned those decisions into working code: the daemon, filesystem store, loop engine, critic, bridge, and dashboard were each built in focused Codex sessions, roughly one slice per session. The workflow: plan in ChatGPT, execute in Codex sessions, review rounds with automated Codex reviewers, then forward-fix commits. The result is zero-dependency plain Node.js. Task state, transcripts, and events are JSON and NDJSON files. The dashboard is one local HTML file. AgentLoop then runs Codex CLI as both its worker and critic engine. Codex built a tool that drives Codex.

Challenges I ran into

Context rot: long chats collect stale assumptions, so every worker and critic is a fresh process and the files are the memory. Critic reliability: vague rubrics made verdicts thrash, so the critic contract requires the final line to be exactly VERDICT: PASS or VERDICT: FAIL with concrete fixes. Process control on Windows: spawning, timeouts, and cancellation of CLI sessions took real care. Securing the bridge: loopback-only ports, token auth, and a tunnel for the hosted connector.

Accomplishments that I'm proud of

The full chain works end to end: ChatGPT sends a goal, the daemon loops fresh workers, the critic enforces the rubric, and shipped code lands on my machine with no human relay. The demo run is real: cycle one fails, the critic writes the fix list, cycle two passes, and polish mode ships it on cycle three. In a separate evaluation with no forced failure, cycle one produced nine passing tests, but the fresh critic found a mixed percent-decoding defect; cycle two fixed it, added regression coverage, passed 11 tests, and received PASS. All with zero package dependencies.

What I learned

Standards belong in files, not prompts. A rubric the critic reads every cycle beats instructions a human repeats every session. Fresh context beats long chats for unattended work. And observability builds trust: a loop you can watch is a loop you can leave alone.

What's next for AgentLoop

Research loops that gather sources before writing against a rubric. Two-way messages so the dashboard can answer agent questions. And more engines: the engine layer is pluggable, Codex ships first.

Built With

  • agent
  • automation
  • chatgpt
  • cloudflared
  • codex
  • css
  • developer-tools
  • gpt-5.6
  • html
  • javascript
  • local-first
  • mcp
  • node.js
  • openai
  • orchestration
  • tool
Share this project:

Updates