Build an open-source, model-agnostic coding-agent harness for power users

You heard of claude code, codex, phi, opencode, aider, let's build together the next state of the art coding harness. Build an open-source (MIT) coding-agent harness for power users: the orchestration layer that turns any frontier or open-weight LLM into a capable, observable, scriptable software-engineering agent. Today's harnesses (Claude Code, Cursor, Codex CLI, Continue, aider) each hardcode one model family, one execution loop, and one UX, with config and "rules" fragmented across incompatible files. Build the harness those tools should have shared: every layer swappable, the agent loop just one of several execution strategies, and every run traceable and reproducible. Language: Go — single static binary, first-class concurrency, cross-platform. Ship clean module boundaries, a CI test suite, and docs so each milestone's artifacts are legible in the public build log. Core design principles: - Provider-thin. A minimal provider interface (chat, tools, streaming, token accounting) behind which Claude Fable 5, GPT, Gemini, ollama, and open-weight models (Kimi, Qwen3-Coder, GLM, DeepSeek via OpenAI-compatible endpoints) are interchangeable. No provider-specific logic leaks into the core. - Swappable execution model. The agent loop is the default, not the only option: the scheduler is pluggable across agent-loop, state-machine, graph/flow, and event-driven strategies, chosen per task. Most open-source harnesses hardcode the loop; this one treats it as one strategy among several. - Everything is a module. Tools (native + MCP), memory, scheduler, provider, sandbox, and UI are swappable components behind stable interfaces, configured as code. - Observable by default. Every run emits OpenTelemetry traces — spans per step, tool call, and token cost — so agent behavior is debuggable and the ledger is grounded in real telemetry. - Power-user first. Headless and scriptable as a first-class mode (pipe-able, CI-friendly, exit codes), with a Bubble Tea TUI on top — not a TUI with a bolted-on API. Power-user capabilities: - Async parallel agents — fan out independent subtasks concurrently, with per-agent token/cost budgets. - Speculative execution — run candidate approaches in parallel, keep the winner, with a review/merge workflow. - Persistent cross-session memory — embedded vector store (SQLite-backed, no external service) for repo and context recall. - Cost routing — route each step to the cheapest adequate model per a declared policy; hard budget ceilings that stop spend. - Capability-scoped sandboxing — an explicit permission model for filesystem, network, and shell; nothing runs unsandboxed by default. - One unified rules/config format that replaces the per-tool zoo of instruction files. Suggested milestone staging (each independently useful, so a stalled build still ships a working tool): 1. Minimal working harness — one OpenAI-compatible provider, agent-loop scheduler, native file/shell tools, basic TUI. End-to-end: give it a repo and a task, it edits and runs code. 2. Modular core — provider interface plus 2–3 providers; pluggable scheduler with agent-loop and state-machine strategies; MCP tool support; OTEL tracing. 3. Power-user layer — async parallel agents, speculative execution, cost routing with budget ceilings, capability sandboxing. 4. Memory + ergonomics — persistent vector memory, unified config/rules format, headless scripting mode, full TUI, plugin docs. 5. Bootstrap — harden it until the harness is capable enough to develop itself; ship reference plugins and a getting-started guide. Quality bar: reproducible builds, a CI test suite, an architecture doc, and at least one worked end-to-end example per milestone so backers can see exactly what each pool bought.