How It Works
The loop that gives your agent a memory and makes it show receipts — every session, every change.
The reliability loop
Five stages keep the work honest from idea to merge. Nothing gets generated without a spec, grounded without your code, or shipped without verification.
Specify
Socratic spec engine: requirements, design, and tasks with an approval gate.
Ground
RAG retrieval cites your code so the agent doesn't invent APIs.
Build
The agent executes the spec'd tasks — 21 workflows: review, tests, bug prediction, refactor.
Remember
Cross-session memory and a lessons corpus surface what worked before.
Verify
Fact-check generated content: imports, flags, links, counts — all real.
What's working underneath
Memory powers every stage of the loop — with four supporting capabilities, each real and shipped.
Your agent stops starting from zero
Findings from each session are stashed and recalled in the next. A retrievable lessons corpus surfaces the right engineering lesson at the moment a prompt needs it.
- Local-first by default — no cloud required
- Redis semantic tier, client included (local Ollama embeddings)
- Automatic recall, or on demand with /recall
- Git-tracked files in your repo — served to Claude Code, Codex, or Antigravity alike. Switch agents; keep everything.
Forms that improve how you and the AI talk
Attune improves human/AI communication by dynamically using interactive forms: instead of a fixed wall of prose, it renders the right form in response to your prompt whenever a structured turn communicates better than text. A multi-part question becomes one click; a recommendation arrives as weighable cards; a disagreement is shown side-by-side so you overrule it in one tap.
- Intake, decision, and pushback fire at a fork; progress reports status
- Rich on widget surfaces, graceful menu fallback elsewhere
- Answer with one click — or the terse y / go / 1 vocab
Specialist teams, not one prompt
21 workflows run teams of 2–6 Claude subagents to review code, surface vulnerabilities, generate tests, and plan refactors — with cost-tiered model routing.
- Security audit, code review, bug prediction, release prep
- Cheap / capable / premium model routing
- Structured, readable reports
Answers anchored to your code
Keyword + semantic retrieval keeps generated content grounded in your actual source. Mean faithfulness 0.97, CI-gated — drift fails the build.
- Powered by attune-rag — built in, no extra install
- Citations back to source
- Faithfulness measured, not assumed
Catch hallucinations before they ship
Fact-check LLM output against source-of-truth: confirm imports import, CLI flags are real, links resolve, and counts match — before the change reaches main.
- Powered by attune-verify — built in, no extra install
- Verifies docs, code, and generated content
- Closes the loop the spec opened
- Cross-model review and roundtable deliberation — advisory; you decide
The agent asks with structure — go ahead, answer it
Both of these are live renders from the production form pipeline, not mockups. Left: scope an audit — a recommended decision card with tradeoffs, multi-select, a dropdown, a bounded number, free text. Right: a session retro triaged one tap per item. Submit either empty and validation catches you.
Live embed — filling it here goes nowhere; in a session, answers come back validated.
The session retro as a triage form — real items from the session that built this demo, ruled one tap each.
Three models. One project brain. You chair.
The final QA check before you ship: /roundtable convenes Claude Code, OpenAI Codex, and Google Antigravity — three agents sharing one project memory — to deliberate the question on a shared board. Every seat is advisory. Nothing is adopted until you promote it.
Deliberate
Each model posts positions and critiques to a shared, Redis-backed board — three different frontier models reasoning about the same question, not one model agreeing with itself. Work crosses seats as git-verified handoff packets, re-verified against the actual tree on resume.
You decide
The seats advise; only the chair promotes. You rule on what gets adopted, and the ruling is recorded — a decision that outlives the session.
Receipts, still
A claim without a receipt doesn't ship — even between AIs. Promoted actions get an executed receipt posted back to the board, closing the loop between a ruling and its execution.
For a lighter touch, /cross-review gets one advisory second opinion on a real diff from a different model than the one that wrote it. It earns its keep: one release exists because a cross-provider receipt probe caught a protocol bug the primary client silently tolerated.
The Agent Drafts. You Approve. The Platform Verifies.
Reliability isn't a vibe — it's a gate at each end of the work.
The spec gate
- •Requirements, design, and tasks are written and approved before a line of code
- •Socratic discovery scopes the work with you, not around you
- •The spec is the contract the build is measured against — and the ladder the agent executes between your approvals
The verification gate
- •Generated claims are fact-checked against your real source
- •Imports import, CLI flags are real, links resolve, counts match
- •Hallucinations are caught before the change reaches main
Ready to give your agent a memory?
Install from PyPI and run /spec on your next feature.