ARIA — Applied Reasoning and Insight Architecture

Agent Memory · Context Engineering · Planning & Reasoning · Human-in-the-Loop Governance

ARIA is the missing infrastructure layer for production AI coding agents: persistent memory that survives context compaction, deliberate context engineering that loads the right knowledge before action, human-governed trust gates that keep AI from acting on noise, and structured session discipline that gives agents the continuity needed for long-horizon reasoning.

The AI captures. The human promotes. Trusted knowledge acts.

New to ARIA? See QUICKSTART.md — 5-minute setup + best practices by session phase.

ARIA is a local-first knowledge and execution-discipline layer for AI coding sessions. It ships as a family of ports — Claude Code (plugin-claude-code/), Claude Cowork (plugin-claude-cowork/), OpenAI Codex (plugin-openai-codex/), Antigravity (plugin-antigravity/), and Cursor (plugin-cursor-template/) — all sharing the same ~/Projects/knowledge/ folder. Insights captured in one tool flow into another. The folder itself is plain markdown — readable by any AI, any human, any editor, with or without ARIA installed.

ARIA manages a complete knowledge lifecycle: it captures insights, decisions, and feedback during sessions; stages them in backlogs for human review; promotes what matters into a searchable, tag-indexed knowledge base; and applies that trusted knowledge back into future tasks, edits, and handoffs. Session hooks prevent knowledge loss during context compaction, surface relevant knowledge when tasks are created, and enforce a visible change decision framework at every file edit.

Why ARIA

Production AI coding agents do not usually fail because the model is incapable. They fail because the working system around the model is incomplete. ARIA addresses four failure modes that repeatedly break agentic work in practice.

Agent Memory

Every session starts from zero. Context compaction erases decisions. Debugging discoveries disappear into transcripts. The next session reopens questions that were already settled.

ARIA gives your agent persistent, structured memory across sessions and across tools. It captures insights during work, stages them for review, and builds a durable knowledge base that survives session boundaries.

Context Engineering

What the model sees determines what it does. Most teams still treat this as an ad hoc prompt-writing problem.

ARIA engineers context deliberately. It surfaces relevant knowledge at task creation time, loads project-specific rules and patterns before edits, and grounds work with artifacts like code maps, cross-repo stitch tables, and repository-aware task specs — so the model always acts on current, accurate context rather than assumptions.

Planning & Reasoning

Long-horizon work fails when the agent loses continuity between decisions, constraints, and active workstreams.

ARIA does not implement planning algorithms. It solves the continuity layer planning depends on: /distill turns tickets into grounded task specs that cite real files, /codemap gives structural codebase awareness, /stitch builds cross-repo bindings, and /handoff preserves full session state so reasoning chains do not break at session boundaries.

Human-in-the-Loop Governance

Auto-memory tools drift. They accumulate noise alongside signal, and the model eventually acts on unreviewed assumptions.

ARIA keeps humans in the loop. The AI captures candidate knowledge, but humans review and promote what becomes trusted. Audit logs and disposition history live in your own repo under git — not a vendor dashboard. Every promotion is explicit and traceable.

The Core Idea

Most memory tools help an assistant remember more. ARIA goes further: it asks what knowledge is worth trusting, how it should be reviewed, and how trusted knowledge should actively shape the next decision, task, and code change.

That is the difference between passive memory and applied operational knowledge.

How It Works

Knowledge moves through a five-phase lifecycle: Capture → Govern → Promote → Apply → Refresh.

Capture

Preserve session knowledge before context evaporates.

• /extract — Scan conversations for uncaptured insights, decisions, feedback, references, and ideas. Deduplicates against existing entries.
• /ask — Research a question, check existing knowledge first, save the answer directly as a knowledge doc.
• /intake — Capture knowledge from outside the conversation. A single URL or text snippet clips whole to intake/clippings/; files/dirs/globs bulk-scan into the backlogs; /intake extract decomposes a source (incl. a Notion/Confluence/Google Doc via a connected ~~docs MCP) into backlog entries; /intake doc <url-or-title> (v2.17.0+) captures one structured 5-section artifact + user reaction; /intake thread <id> (v2.33.0+) pulls a chat/email thread via a connected ~~chat/~~email MCP. (v2.33.0 consolidated three former standalone capture skills — quick-clip, thread-capture, and doc-extract — into these /intake modes.)
• /interview <mode> (v2.31.0+) — Elicit knowledge through dialogue rather than harvesting it. Three modes: project (scope a new build), knowledge (get a topic out of your head into the KB), deep-dive (extract the rationale behind something you already built — requires a basis via --ground). Cadence (one-at-a-time socratic vs research-then-batch battery) is chosen in-session. Stages to intake/projects|interviews/ for manual review.

Govern

Convert raw capture into reviewable candidates.

• All captured knowledge stages in a backlog — nothing enters the trusted layer automatically.
• Human review is the gate between capture and promotion.
• Provenance is preserved so every piece of knowledge is inspectable and auditable.

Promote

Move reviewed knowledge into the trusted layer.

• /audit-knowledge (al