zeroshot
Multi-agent graph harness for Claude Code, Codex and other coding agents. Separate agents review and test the work. Runs locally on your subscription.
- 2.2k
- Rust
- MIT
- 2 d ago
Your coding agent can’t quietly undo what you already decided. PROOF9(TM) records a bug as a requirement, locks it to the code it affects, and checks it before every commit. A Claude Code plugin plus a CLI. Apache-2.0.
Repo frankbria/codeframe, read from GitHub 2 d ago. frankbria has not joined Take My Repo.
frankbria/codeframe is a public repo on GitHub by frankbria. Your coding agent can’t quietly undo what you already decided. PROOF9(TM) records a bug as a requirement, locks it to the code it affects, and checks it before every commit. A Claude Code plugin plus a CLI. Apache-2.0. It declares the Apache-2.0 license on GitHub. It is written mainly in Python, has 24 stars and last changed on 2026-11-14. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-20.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Your coding agent can’t quietly undo what you already decided.
Every bug you fix once, fixed forever: recorded as a requirement, locked to the code it affects,
and checked before every commit. Regression memory for coding agents.
Quick start · Demos · CLI guide · proof9 plugin · Docs · Changelog
At a Claude Code prompt:
/plugin install proof9 --marketplace frankbria/codeframe
The plugin needs the cf CLI on your PATH: uv tool install codeframe-ai.
A real session on codeframe 0.9.7 (cast: docs/images/proof9-loop.cast).
Asked for a change that would undo a past decision, Claude finds the locked
requirement, keeps it, and says what it would take to change it on purpose.
TDD protects your code. This protects your tests. Your agent can edit a test
as easily as it can edit the code, and when a test is inconvenient that is often
what it edits. A requirement names the test that proves it, and the check before
each commit fails if that test was deleted, skipped or had its body rewritten,
even when no other code changed. Changing it on purpose is recorded with
cf proof rebaseline and a reason; releasing the requirement takes a waiver with
a name, a reason and an expiry date. Helpers and fixtures the test calls are not
fingerprinted yet (see What we don't do yet).
A plain git pre-commit hook refuses a commit that brings back a fixed bug
(cast: docs/images/refused-commit.cast;
how it was recorded).
Coding agents have become very good at writing code. What they have no memory of is what already went wrong. A bug you found, fixed and moved on from is, to the agent, just more code it is free to change next week.
CodeFRAME gives it that memory. A defect is recorded as a requirement, scoped to the code it affects, with a named test that proves it stays fixed. Every later change to that code is checked against it — before the commit in a Claude Code session, and again before the merge. Nothing is dropped silently: a requirement is released only by a recorded waiver.
Other tools remember what your reviewers prefer. CodeFRAME remembers what actually broke, and proves it stays fixed: evidence is checksummed and bound to the run and gate that produced it, a run that verified nothing is reported as vacuous rather than green, and every waiver records who approved it, why, and (when set) when it expires. Where each of those lives in the code is listed in VISION.md.
The same CLI also covers the work before the code — requirements discovery, task decomposition, and delegating each task to Claude Code, Codex, OpenCode, Kilocode or its built-in agent. See Features.
Proof of substance. 6,000+ automated tests passing in CI, an 80% test coverage floor CI enforces, and a sample evidence report showing what a run actually produces.
[!NOTE] CodeFRAME is in public beta (
0.9.8). The Golden Path CLI (cf init/prd/tasks/work/proof/pr) is stable enough to build on. Anything marked in progress in the roadmap is still moving, and on-disk.codeframe/formats may change between betas. Report rough edges.
The proof9 plugin brings the proof ledger into a Claude
Code session: /proof captures a bug or locks in passing tests, every commit
Claude makes is checked against the ledger first, and a failing requirement
shows above the prompt. A ledger pane beside the transcript lists every
requirement with its evidence and run history.
The CLI is the primary interface and needs no server. Below, a real session initializes a workspace, imports a PRD, generates 18 dependency-ordered tasks with one LLM call, and captures a bug as a PROOF9 requirement.
Sped up; the LLM wait is trimmed. Full walkthrough and command reference: CLI guide.
Prerequisites: Python 3.11+, git, and an API key for your LLM provider. By
default that is ANTHROPIC_API_KEY from
console.anthropic.com. OPENAI_API_KEY works
with --llm-provider openai, and local providers such as Ollama need no key.
1. Install
uv tool install codeframe-ai # installs the `cf` command
cf --help
pipx install codeframe-ai works too, or run it without installing via
uvx --from codeframe-ai cf --help. The package is codeframe-ai; the command is cf.
2. Set your API key
export ANTHROPIC_API_KEY="sk-ant-..."
# or store it once: cf auth setup --provider anthropic
3. Think: requirements and tasks
cd /path/to/your/project
cf init . --detect # create the workspace, detect the tech stack
cf prd generate # Socratic discovery (or: cf prd add PRD.md)
cf tasks generate # dependency-ordered tasks, created in BACKLOG
cf tasks list
4. Build: run one task
cf tasks set status <task-id> READY
cf work start <task-id> --execute # built-in agent
cf work start <task-id> --execute --engine claude-code # or codex, opencode, kilocode
If the agent needs a decision it cannot make, it stops and files a blocker.
cf blocker list shows it and cf blocker answer <id> "..." unblocks the task.
5. Prove: capture a requirement, then verify it
cf proof capture --title "add() is wrong for negatives" \
--description "add(-1, -1) returned 0" --where src/calc.py --severity high --source qa
# turn the generated tests/proof/REQ-0001/draft_*.py stubs into real tests, then:
cf proof run --full
cf proof capture also works on its own in any git repository. It creates
.codeframe/ on first use, so you can start recording defects without cf init.
To start from the tests you already have, cf proof ratchet locks every
currently-passing test in as a requirement, so it cannot silently stop passing.
In Claude Code: the proof9 plugin. At the prompt of a Claude Code session:
/plugin install proof9 --marketplace frankbria/codeframe
(From a shell: claude plugin install proof9 --marketplace frankbria/codeframe.)
It adds /proof to capture a bug or lock in passing tests, checks the ledger
before every commit Claude makes (warning by default), and shows a failing
requirement above the prompt. It needs codeframe-ai 0.9.7 or later on your
PATH. See proof9/README.md.
6. Ship
export GITHUB_TOKEN=... GITHUB_REPO=owner/repo
cf pr create
cf pr merge <number> # refused while an in-scope requirement is open
An empty directory through a green cf proof run takes about 6 minutes on
a clean machine: measured, step by step.
The CLI guide explains each step in depth,
including batch runs over a whole backlog.
git clone https://github.com/frankbria/codeframe.git && cd codeframe
curl -LsSf https://astral.sh/uv/install.sh | sh
uv venv && source .venv/bin/activate && uv sync
uv run cf --help
| Stage | What CodeFRAME does | Commands |
|---|---|---|
| Think | Socratic requirements discovery, ambiguity stress-testing, task decomposition with dependencies | cf prd generate · cf prd stress-test · cf tasks generate |
| Build | Runs each task on the engine you choose, with verification gates, self-correction, stall detection and human-in-the-loop blockers | cf work start --engine … · cf work batch run |
| Prove | PROOF9™: every glitch becomes a permanent requirement, verified across nine gates with checksummed evidence | cf proof capture · cf proof run |
| Ship | Pull requests carry the proof report; merge is blocked while an in-scope requirement is open | cf pr create · cf pr merge |
/done to finish on demand. Uncovered areas become open questions in the PRD.--engine.UNIT and
CONTRACT run pytest and SEC runs bandit with no work from you. E2E,
VISUAL, A11Y, PERF and DEMO generate a named stub per obligation —
test_a11y_*, test_perf_* and so on — which you implement; the gate then runs
it by name, and a missing test is a failure, never a pass. MANUAL is never
machine-verified and is resolved only by a justified waiver.cf proof run checks the requirements your uncommitted
changes touch, satisfied ones included: through the code a requirement
protects, or through its own tests (deleted, skipped, rewritten, its pin under
tests/proof/, or a conftest.py above them). --full checks every
requirement except waived ones.cf pr merge, scoped to the
PR's changed files (renames included). An override requires a reason and is
recorded in an audit ledger.cf stats).cf dashboard) for watching a workspace from the terminal.Published deliberately. Extended rather than quietly shortened.
conftest.py change re-runs the requirement but
passes if the test still passes. The fingerprint covers the files a bare
pytest collects (testpaths, norecursedirs, python_files and
pythonpath are read, from any config file pytest 9 reads, pytest.toml
included; a conftest's collect_ignore is not, so a same-named test there
still counts).
The fingerprint includes the marks and the if/try path around the test,
and the module or class constants its parametrize names; a constant
imported from another module is not followed. A test generated at
collection time, or bound through an import CodeFRAME cannot follow (a
sys.path change in a conftest, or any --import-mode but the default),
cannot be fingerprinted; the pytest verdict still guards it, but a weakened body there
goes unseen. A requirement satisfied before this check existed gets
its fingerprint at its next passing run, and that first record trusts the body
the test has then. cf proof rebaseline is an audited path, not a barrier: it
records who accepted a changed test and why, like a waiver, and anyone who can
run cf can run it. The merge gate counts a test-only change only for a
requirement that is already open; catching the edit itself is the pre-commit
check's job.UNIT, CONTRACT and SEC
run on their own. E2E, VISUAL, A11Y, PERF and DEMO generate named stubs
you implement. MANUAL is never machine-verified./config, mode: block). In block mode it fails closed: if the check cannot run,
the commit is denied rather than waved through.cf proof capture. ┌──────────── cf CLI · cf dashboard (TUI) ────────────┐ ┌── proof9 plugin (Claude Code) ──┐
│ direct calls, no server required │ │ runs cf proof … --json │
└──────────────────────────┬──────────────────────────┘ └────────────────┬────────────────┘
▼ ▼
┌────────────────────────────────────────────────────────────────────────────────────────┐
│ codeframe/core: headless domain and orchestration │
│ THINK prd · discovery · stress test · tasks · dependency graph │
│ BUILD runtime · conductor · gates · self-correction · stall detection │
│ PROVE PROOF9 ledger · scope · evidence │
│ SHIP GitHub PRs · merge gate │
└───────────┬──────────────────────────────┬─────────────────────────────────────────────┘
▼ ▼
Coding engines LLM providers Storage
Claude Code · Codex · OpenCode Anthropic · OpenAI · .codeframe/state.db
Kilocode · built-in ReAct any OpenAI-compatible (per workspace)
The core is headless and runs entirely from the CLI; the proof9 plugin drives
it through cf proof. See Agent System Reference
for the execution flows.
# Required for the default provider
export ANTHROPIC_API_KEY=sk-ant-...
# Another provider (optional)
export CODEFRAME_LLM_PROVIDER=openai # anthropic | openai | ollama | vllm | compatible
export CODEFRAME_LLM_MODEL=gpt-4o
export OPENAI_API_KEY=sk-... # not needed for local providers
export OPENAI_BASE_URL=http://localhost:11434/v1 # Ollama, vLLM, LM Studio, ...
Per-workspace settings live in .codeframe/config.yaml (an llm: block, and
discovery_max_questions). For the LLM provider and model, precedence is CLI
flag, then environment, then workspace config, then default.
Telemetry is opt-in and off by default. When enabled it sends the command
name, duration, exit code, version and OS, never code, prompts, arguments or
file paths. Control it with cf config telemetry on|off|status,
CODEFRAME_TELEMETRY=on|off, or DO_NOT_TRACK=1. See PRIVACY.md.
| Guide | What's in it |
|---|---|
| CLI guide | Walkthrough plus the complete command reference |
| proof9 plugin | The proof ledger inside Claude Code |
| Quickstart | Install, keys, first run |
| Cold start on a clean machine | A measured, narrated run of the Golden Path |
| Golden Path | The CLI-first workflow contract |
| Product roadmap | Phase plan and feature status |
| Vision | The Think → Build → Prove → Ship thesis |
| Agent system reference | Agent components, model selection, execution flows |
| ReAct agent architecture | Tools, editor, token management |
Think, Build, Prove and Ship all work end to end from the CLI. The web UI and server were removed in #1477; the CLI and the proof9 plugin are the product. The product roadmap is the authority on phase status.
Next up
Think
cf prd stress-test: recursive decomposition that surfaces ambiguities before executionBuild
cf work replay, built-in ReAct engine)cf dashboard)Prove
cf proof capture: the glitch-to-requirement closed loopcf proof ratchet: lock in every currently-passing test/proof, pre-commit ledger check, ledger paneShip
cf pr merge, scoped to the PR's files, with an audited override (actor + reason)uv sync --extra dev && pre-commit install
uv run pytest tests/ --ignore=tests/e2e -m "not lifecycle" # the CI gate
uv run ruff check .
The suite has 6,000+ tests, and contributions need 80% test coverage, the floor CI enforces. Code standards are ruff, type hints and tests with every change. During the beta, feature ideas go to Discussions → Ideas before code. See CONTRIBUTING.md for what is stable and how to propose changes.
security@codeframe.sh, never in a public issue. See SECURITY.md.hello@codeframe.sh (pricing).hello@codeframe.sh or
reply to the pinned Discussion.Apache-2.0: free to use, modify and distribute, including in commercial and closed-source products. Keep the license and NOTICE file with any copy you distribute, and mark the files you change. See LICENSING.md for a plain-language explanation.
CodeFRAME® is a registered trademark, and the CodeFRAME logo and PROOF9™ are trademarks, of Noatak Enterprises, LLC, dba Bria Strategy Group. None of them are licensed under Apache-2.0. See TRADEMARKS.md.
Built by Frank Bria
Issues ·
Discussions ·
Documentation
CodeFRAME® is a registered trademark and PROOF9™ is a trademark of Noatak Enterprises, LLC, dba Bria Strategy Group. All rights reserved.
frankbria/codeframe is a public repo on GitHub by frankbria. Your coding agent can’t quietly undo what you already decided. PROOF9(TM) records a bug as a requirement, locks it to the code it affects, and checks it before every commit. A Claude Code plugin plus a CLI. Apache-2.0.
It declares the Apache-2.0 license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-14. GitHub counts 16 open issues and pull requests. Take My Repo does not judge from that whether it is maintained.
Multi-agent graph harness for Claude Code, Codex and other coding agents. Separate agents review and test the work. Runs locally on your subscription.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.

CLI proxy that reduces LLM token consumption by 60-90% on common dev commands. Single Rust binary, zero dependencies

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
Reverse engineer anything with agents, from app behavior down to native binaries.
Open source, self-hosted AI code review. Bring your own LLM.

3,000+ reusable AI agent skills for Claude Code, Codex, Cursor and Gemini CLI. AAS Core adds local catalog discovery, agent-owned selection and plan preview. CLI, MCP and plugins.
Autonomous AI development loop for Claude Code with intelligent exit detection
Automated parallel management of Claude Code versions using Git worktrees and autonomous coordination between agents in separate terminals
AI-powered book authoring platform that guides writers from concept to draft through interactive interviews, voice/text input, and intelligent content generation. Features rich text editing, automated table of contents, Q&A-based development, and PDF/DOCX export.
AI-powered conversational data modeling platform — upload data, chat with AI, build ML models, deploy predictions. No code required.

AI Music Platform — end-to-end prompt-to-distribution pipeline with DAW integration and VST3 plugin
SprintForge is an open-source, macro-free project management system that generates sophisticated Excel spreadsheets with Gantt chart capabilities and probabilistic timeline predictions. Unlike existing solutions, SprintForge prioritizes agile sprint planning, enterprise security, and multi-user collaboration with Excel as the source of truth.
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/frankbria/codeframeTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.