Build software from specifications, not prompts.
Attune-AI gives your AI coding agent a spine: write a spec, ground every change in your real code, carry what worked into the next session, and verify the output before it ships. Workflows, memory, retrieval grounding, and verification — one platform for Claude Code.
Socratic spec engine: requirements, design, and tasks with an approval gate.
RAG retrieval cites your code so the agent doesn't invent APIs.
17 multi-stage workflows: review, tests, bug prediction, refactor.
Cross-session memory and a lessons corpus surface what worked before.
Fact-check generated content: imports, flags, links, counts — all real.
- AI generates code.
- Projects require knowledge.
- Specifications drift.
- Documentation gets stale.
- Decisions disappear.
Attune keeps software aligned with its requirements by combining five capabilities — each one a job, not a buzzword:
- Spec-driven development keeps requirements from drifting.
- Project memory preserves decisions across sessions.
- Grounded retrieval anchors outputs to your real code.
- Synchronized docs stay current as the code changes.
- Verification reduces hallucinations before they ship.
Four pillars, one outcome
Each pillar is a real, shipped capability — not a roadmap promise. Together they keep your AI agent's work grounded, remembered, and verified.
Specialist teams, not one prompt
17 multi-stage 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
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
- Optional Redis semantic tier (local Ollama embeddings)
- Automatic recall, or on demand with /recall
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.
- Verifies docs, code, and generated content
- Closes the loop the spec opened
- Built from the discipline that runs this project
attune-rag — grounding you can use anywhere
The retrieval engine inside attune-ai is its own package. Lightweight, LLM-agnostic RAG with pluggable corpora — works with Claude, Gemini, or any LLM. Built into attune-ai for grounding, and equally happy standing on its own in any Python project.
pip install attune-ragClaude, Gemini, or any model — not locked in
CI-gated — drift fails the build
Point it at docs, code, or any source
Drop into any project, or get it free with attune-ai
Powered by Redis when you want it
Memory is local-first by default — nothing leaves your machine. Plug in Redis Agent Memory Server for semantic search over your project memory: local Ollama embeddings, int8 vector quantization, no cloud required.
pip install 'attune-ai[redis]'Default backend is on-disk — no service required
Opt in for semantic recall across sessions
Runs locally — no API key, no cloud
Compact vectors, shipped in attune-ai 7.4
The Documentation Toolchain
attune-ai began as a tool to help people work with AI, then grew into an engineering toolkit focused on Claude — and later Redis. The documentation toolchain came after, built with the same development discipline, and split off as four standalone packages forming an end-to-end author → reader loop. Use the full stack, or drop in just the piece you need.
- 1
attune-authorGenerates 15 kinds of source-grounded templates with per-type LLM polish. Runs at dev time or in CI.
- 2
attune-ragKeyword + semantic retrieval, mean faithfulness ≥ 0.97 (CI-gated) — answers stay grounded in your code.
- 3
attune-helpReads the templates at runtime. 1 dependency, no API key required. Embed in any Python tool.
- 4
attune-guiLocal dashboard. Browse templates, edit specs, run commands — one pane for the whole stack.
All four are open source — Apache 2.0.
# 1. attune-author — generate polished, source-grounded
# templates from your codebase (CI or dev time)
from attune_author.generator import generate_feature_templates
generate_feature_templates(feature, help_dir=".help", project_root=".")
# 2. attune-rag — keyword + semantic retrieval keeps
# answers grounded. Mean faithfulness ≥ 0.97, CI-gated.
# 3. attune-help — read them at runtime. 1 dependency,
# no API key required. Embed anywhere.
from attune_help import HelpEngine
engine = HelpEngine(template_dir=".help/templates")
print(engine.lookup("security-audit"))
# 4. attune-gui — local dashboard tying it all together.
# pip install attune-gui && attune-gui --openSix Ways to Use It
The attune-ai framework, its Claude Code plugin, and the four-package documentation toolchain we built with it. Pick the piece that fits the job.
attune-ai
Full framework. Workflows, staleness detection, MCP server, and 17 auto-triggering skills for Claude Code.
attune-help
Lightweight reader. 1 dependency, 6 files. Embed progressive help in any CLI tool, notebook, or internal app.
attune-author
AI authoring companion. Generates 15 kinds of source-grounded templates with per-type polish prompts.
attune-rag
Keyword + semantic retrieval over your Markdown corpus. Mean faithfulness ≥ 0.97, CI-gated — answers stay grounded.
attune-gui
Local dashboard. Browse templates, edit specs, run commands, and watch jobs — one pane for the whole stack.
Claude Code Plugin
Type /coach in Claude Code. Progressive help in your terminal — no setup required.
Ship software you can trust your agent built
Install from PyPI, run /spec on your next feature, and let the platform keep the work grounded, remembered, and verified.
Source hashes detect code drift. Stale templates regenerate automatically — your docs stay in sync with your codebase.
Edit generated templates freely, or write from scratch. The engine respects hand-written content and never overwrites your work.