agentloop
Conductor plans, native memory, hard budgets, and external ship gates — in the agent you already use.
Multi-step work goes through Conductor first. Execute waits for your yes. Done means the outside world agrees.
Works where you already code
Multi-step work gets a structured scaffold: consumption estimates, parallelization map, agent picks, risks, and hard stop budgets. Execute waits until you approve.
Open conductor-plan →
GitHub
conductor = {
scaffold: "slices + verify",
estimate: "turns · context · cost",
parallel: "map · swarm verdict",
gate: "await approval",
stop: ".agentloop/stop.yaml"
}
Native store at .agentloop/memory/. Upsert, supersede, contradict, digest. Handoffs carry the next action and memory keys so another chat continues without re-explanation.
scripts/memory.sh session-brief scripts/memory.sh upsert --key … scripts/memory.sh supersede old --key new .agentloop/handoff.md → next action context-surgeon → continuous
Spawn workers only for large, independent tracks — and only when Conductor’s swarm verdict is surgical and approved. One strong composed pass beats five shallow ones.
Open the swarm skill →verdict surgical | none workers 3 / 3 cap depth ≤ 2 compose preferred for craft quality over noisy parallel
Tests, lint, types, diff budget, scope check. Hard budgets in stop.yaml. The model does not grade its own homework.
tests 12/12 lint 0 warnings types clean max_turns honored ───────────────── status ready to merge
Plugin install, or install.sh to seed Conductor-ready .agentloop/ templates. Use --full for commands, hooks, and helper scripts. Then /doctor → /plan → approve → execute.
Local plugin from this repo, or project bootstrap via install.sh.
Install agentloop as my coding harness. 1. Clone https://github.com/edenbuilds/agentloop if it is not already local. 2. In Cursor: Customize → Plugins → add this directory as a local plugin (it ships `.cursor-plugin/plugin.json`). 3. Or bootstrap: ./scripts/install.sh /path/to/this/project # optional full surface: ./scripts/install.sh --full /path/to/this/project 4. Run /doctor. Init memory: scripts/memory.sh init 5. For multi-step work: /plan → wait for my approval → then /agentloop or /pev. External ship gate. Quality over swarm. Council only on consequential calls. Keep .agentloop/handoff.md current. Follow AGENTS.md. Method lenses only. Never celebrity cosplay.
git clone https://github.com/edenbuilds/agentloop.git cd agentloop ./scripts/install.sh /path/to/your/project ./scripts/install.sh --full /path/to/your/project # optional ./scripts/doctor.sh ./scripts/memory.sh init
Plugin directory flag, or CLAUDE.md + skills via bootstrap.
Install and enable agentloop for this session. 1. If the repo is not cloned: git clone https://github.com/edenbuilds/agentloop.git 2. Start Claude Code with the plugin: claude --plugin-dir /absolute/path/to/agentloop 3. Or bootstrap: /path/to/agentloop/scripts/install.sh . /path/to/agentloop/scripts/install.sh --full . # optional 4. Read @AGENTS.md. Run /doctor, then for multi-step work: /plan → await approval → /pev or /agentloop. Native memory: scripts/memory.sh. External gates only. Quality over swarm. Opus prompting patterns live in skills/opus-prompting. No celebrity cosplay.
git clone https://github.com/edenbuilds/agentloop.git claude --plugin-dir "$(pwd)/agentloop"
Skills under .agents/skills, marketplace pointer, root AGENTS.md.
Set up agentloop for this repository. 1. Clone https://github.com/edenbuilds/agentloop if needed. 2. Run: ./agentloop/scripts/install.sh . This copies skills into .agents/skills, .cursor/skills, .claude/skills and installs AGENTS.md / CLAUDE.md when missing. 3. Optionally copy .agents/plugins/marketplace.json from the agentloop repo. 4. Load AGENTS.md as always-on instructions. 5. For the current task, operate in harness mode: restate goal → smallest path → PEV until external verify passes → ship gate. Cap swarm. Council before consequential calls. No AI slop in written artifacts.
git clone https://github.com/edenbuilds/agentloop.git ./agentloop/scripts/install.sh . # merge AGENTS.md if one already exists
Instructions file + skills as reference playbooks.
Adopt agentloop as our coding harness for this repo. 1. Clone https://github.com/edenbuilds/agentloop (or reference the path if present). 2. Merge the operating rules from agentloop/AGENTS.md into .github/copilot-instructions.md (create the file if needed). 3. Run ./agentloop/scripts/install.sh . to copy skills for reference. 4. Treat these as chat macros when slash commands are unavailable: - agentloop: full harness (scope → PEV → ship) - warroom: independent lenses, preserve dissent - pev: plan → execute → verify until tests pass - ship: external verification only - polish: no-ai-slop → humanise → contrasting → SEO/UI 5. Start now: restate my goal, pick the smallest path, and verify with our test/lint scripts.
git clone https://github.com/edenbuilds/agentloop.git ./agentloop/scripts/install.sh . mkdir -p .github # then merge agentloop/AGENTS.md → .github/copilot-instructions.md
Rules / memories + skills install; playbooks for warroom and swarm.
Install agentloop into this Windsurf workspace. 1. Clone https://github.com/edenbuilds/agentloop if needed. 2. Run ./agentloop/scripts/install.sh . 3. Add the Hard laws and Default operating mode from AGENTS.md into Windsurf rules / memories. 4. Use these playbooks in chat: - Full harness: scope → plan → execute → verify → ship - Warroom: independent lenses, then synthesize with dissent preserved - Polish: strip AI slop, humanise, contrast, SEO, UI audit 5. For my current task: write stop conditions first, then execute the smallest path. Verify with project tests/lint. Quality over swarm.
git clone https://github.com/edenbuilds/agentloop.git ./agentloop/scripts/install.sh . # paste Hard laws from AGENTS.md into Windsurf rules
Map agentloop roles to SDK agents and tools. Keep stop conditions in code.
Build an OpenAI Agents SDK orchestration that follows agentloop doctrine.
Map:
- overmind → manager Agent
- first-principles, ship-density, scale-product, craft-critic, verifier → Agent.as_tool()
- ship gate → code-orchestrated verify after each run (tests/lint/types)
- swarm caps → enforce in Python/TS, never prompt-only
Pattern:
while not gate.passed and turns < max_turns:
Runner.run(overmind, state)
gate = run_external_verify()
Read https://github.com/edenbuilds/agentloop/blob/main/adapters/openai-agents-sdk.md
and docs/doctrine.md. Prefer quality compose over parallel workers.
MCP tool exposure is planned. Do not invent an MCP server yet.
# Read: # https://github.com/edenbuilds/agentloop/blob/main/adapters/openai-agents-sdk.md # https://github.com/edenbuilds/agentloop/blob/main/docs/doctrine.md
After install: /doctor → /plan (approve) → /agentloop or /pev. Craft: /polish.
Conductor, memory, doctor, PEV, council, craft. Toggle harness or craft. Every row opens the source.
When output starts to sound like every other AI page, run craft. Strip the sludge. Check contrast. Optional voice stays off unless you turn it on.
Kill “empower,” “leverage,” and interchangeable SaaS mush. Every sentence earns its place.
-> detect "Empower your team" kill "Seamlessly integrate" kill -> humanise concrete verbs only PASSED
craft: no-ai-slop: on humanise: on contrasting: on ponytail: off swarm: never
Tests, linters, typecheckers, diffs. The verifier never grades its own homework alone.
MIT. No cloud lock-in. Same doctrine in Cursor, Claude Code, Codex, Copilot, Windsurf, and SDK patterns.
Same chat. Stronger loop. Clearer stops.
Fig. · harness console (conceptual)
| Mission | Mode | Step | Verify | State |
|---|---|---|---|---|
| auth-refactor | PEV + council | 4 / 6 | 12/12 | Shipping |
| api-migration | Swarm ×3 | 2 / 5 | 8/8 | Running |
| landing-polish | Craft compose | 3 / 3 | Pass | Done |
| onboarding-flow | PEV | 1 / 4 | - | Queued |
Code owns the loop. The LLM reasons inside nodes. It does not invent control flow. Write stop conditions. Prefer quality over swarm. Verify outside the model.
Click the cube
