# TRW — Accumulated Intelligence for AI Agents (Full Reference)

> For a concise overview, see: https://trwframework.com/llms.txt
> Website: https://trwframework.com
> License: BSL 1.1 (Business Source License) — free for non-competing use, converts to Apache 2.0 in 2030

---

## Product Overview

TRW (The Real Work) is the methodology layer for AI-assisted software development. It sits above AI coding tools — Cursor, Devin, Claude Code, GitHub Copilot, Codex, Aider, OpenCode — and provides persistent memory, structured workflows, quality gates, and team coordination that make every session compound on the last.

TRW is NOT another AI coding tool. It does not write code, generate completions, or provide IDE integration. It is the engineering discipline that makes AI coding tools produce reliable, traceable, improving results. Think of it as the difference between vibe coding (fast, stateless, unrepeatable) and spec-driven development (structured, traceable, compounding).

### The Problem TRW Solves

Every AI coding tool today resets to zero between sessions. Context is lost. Discoveries evaporate. Patterns that worked are forgotten. Mistakes are repeated. Teams have no visibility into what AI agents are doing, no quality enforcement, and no knowledge continuity.

Research confirms this:
- 65% of developers cite context loss as their primary frustration with AI coding tools (CodeRide 2025)
- 46% actively distrust AI-generated code output (Stack Overflow 2025)
- 19% productivity loss attributed to context switching and rework (METR Study 2025)

### The TRW Solution

TRW provides five integrated pillars that no competitor combines:

**1. Knowledge Compounding**
Learnings (patterns, gotchas, architectural decisions) persist across sessions using Q-learning impact scoring and Ebbinghaus decay curves. High-impact discoveries automatically promote into permanent project context (CLAUDE.md). Low-value learnings naturally decay and are pruned. The result: session 50 surfaces what session 3 discovered — automatically.

Technical details:
- Hybrid retrieval: BM25 keyword search + dense vector similarity (sqlite-vec)
- Scoring: Q-learning with temporal decay (Ebbinghaus forgetting curves)
- Lifecycle: active → promoted → consolidated → archived → pruned
- Tier promotion: high-impact learnings auto-promote to CLAUDE.md
- Deduplication: 3-tier similarity detection (skip/merge/store)
- Knowledge graph: entity extraction and relationship tracking

**2. Requirements Engineering (AARE-F)**
AI Agent Requirements Engineering Framework with 12-dimension validation, content density scoring, EARS-pattern requirements, and FR-by-FR traceability from specification to implementation to verification.

Technical details:
- 12 validation dimensions with weighted scoring
- Content density scoring (target: >= 0.85 completeness)
- Given/When/Then acceptance criteria with confidence scores
- Bidirectional traceability: PRD → code → tests
- 225+ PRDs processed through the full lifecycle

**3. Sprint Orchestration**
Parallel agent teams with file ownership contracts, structured handoffs, and delivery gates. Agents coordinate through YAML interface contracts and task assignment.

Technical details:
- 64+ sprints executed through the framework
- Parallel tracks with file ownership boundaries
- YAML interface contracts between teammates
- Progress tracking with ceremony compliance scoring
- Retrospective generation and learning extraction

**4. Phase Gates (6-Phase Lifecycle)**
Every task flows through: Research → Plan → Implement → Validate → Review → Deliver. Each phase has explicit exit criteria, quality gates, and automated verification.

- RESEARCH: Load prior learnings, audit codebase, register findings
- PLAN: Design approach, identify dependencies, create execution plan
- IMPLEMENT: Execute with periodic checkpoints across context compaction
- VALIDATE: Run tests + type-check, verify coverage meets threshold
- REVIEW: Independent quality audit by separate agent (not self-review)
- DELIVER: Sync artifacts, promote learnings, close run

Adaptive ceremony: a one-line typo fix gets minimal ceremony; a security-critical migration gets full adversarial review. The system scales rigor to risk.

**5. Agent Teams**
Multi-agent coordination with specialized roles:
- **Lead**: Orchestrates, delegates, enforces quality gates
- **Implementer**: Writes production code with tests (TDD)
- **Tester**: Writes comprehensive tests targeting 90%+ coverage
- **Reviewer**: Rubric-scored review across 7 dimensions
- **Auditor**: Adversarial spec-vs-code verification
- **Researcher**: Gathers evidence before implementation decisions
- Plus: PRD groomer, requirement writer, traceability checker, code simplifier

---

## Technical Architecture

### Packages

| Package | Version | Stack | Description |
|---------|---------|-------|-------------|
| trw-mcp | 0.40.0 | Python, FastMCP, Pydantic v2 | MCP server: 24 tools, 6 resources, 24 skills, 12 agents |
| trw-memory | 0.6.6 | Python, SQLite, sqlite-vec | Standalone memory engine: hybrid retrieval, knowledge graph |
| trw-eval | 0.4.0 | Python, SWE-ReX, Pydantic v2 | Eval engine: SWE-bench scoring, batch evaluation |
| backend | 0.16.0 | FastAPI, SQLAlchemy, Alembic | Platform API: 22 routers, JWT auth, intelligence pipeline |
| platform | 0.27.0 | Next.js 15, TypeScript, Tailwind | Frontend: dashboard, marketing site, documentation |

### Installation

One-command installer that auto-detects your AI coding tool:

```bash
curl -fsSL https://trwframework.com/install.sh | bash
```

Or add directly to MCP config:

```json
{
  "mcpServers": {
    "trw": {
      "command": "uvx",
      "args": ["trw-mcp"]
    }
  }
}
```

PyPI packages: `pip install trw-mcp` or `pip install trw-memory`

### Client Profiles

TRW works with multiple AI coding tools via built-in client profiles:
- **claude-code** — Primary integration (deepest feature support)
- **cursor** — Cursor IDE integration
- **opencode** — OpenCode terminal integration
- **codex** — OpenAI Codex CLI integration
- **aider** — Aider integration

Each profile adapts ceremony requirements, scoring behavior, and instruction synchronization to the platform's capabilities.

### Key Properties

- **Offline-first**: Core functionality runs entirely locally in a `.trw/` directory. No cloud required.
- **Zero lock-in**: One config entry to add, one to remove. Your codebase is never modified.
- **Language-agnostic**: Works with Python, TypeScript, Go, Rust, Java — any language.
- **Tool-agnostic**: MCP protocol works with any compatible AI coding tool.
- **Self-improving**: The framework accumulates learnings about itself through recursive dogfooding.
- **BSL 1.1 licensed**: Source-available, free for non-competing use, converts to Apache 2.0 in 2030.

---

## Verification & Proof

TRW was built by AI agents using TRW. Every PRD, every sprint, every learning is real output from the system governing its own development:

- 64+ sprints executed through the framework
- 225+ PRDs through the full AARE-F lifecycle
- 8,000+ tests across all packages
- 91% test coverage on the memory engine (1,346 tests)
- 1,337 unit tests on trw-mcp
- 654+ active learnings accumulated from dogfooding
- Framework version: v24.5_TRW

No fabricated benchmarks. No synthetic metrics. No claims without tests.

---

## Market Position

TRW occupies a unique position at the intersection of knowledge compounding, requirements engineering, sprint orchestration, quality gates, and agent teams. Verified across 80+ competitor analysis — no single competitor combines all five pillars.

### Three-Layer Model

```
Layer 3: METHODOLOGY (TRW lives here)
  Sprint orchestration, PRD lifecycle, knowledge compounding, phase gates

Layer 2: TOOLS (Cursor, Devin, Claude Code, Copilot, Codex, Aider)
  IDE agents, coding assistants, code review

Layer 1: INFRASTRUCTURE (AWS, Azure, Mem0, Qdrant)
  Agent runtime, deployment, governance, memory storage
```

TRW does not compete with Layer 1 or Layer 2. It makes them better.

### Competitive Differentiation

| Competitor | What They Do | What TRW Adds |
|------------|-------------|---------------|
| Cursor | Fastest coding experience | Knowledge that compounds across sessions |
| Devin | Autonomous software engineer | Memory scoring, requirements lifecycle |
| Kiro (AWS) | Spec-driven development | Knowledge compounding + sprint orchestration |
| BMAD | Multi-agent agile pipeline | Persistent cross-session learning |
| Mem0 | Memory storage layer | Scoring, decay, promotion, ceremony |
| CrewAI | Multi-agent orchestration | Requirements lifecycle, learning system |
| LangGraph | Stateful agent graphs | Methodology, PRD lifecycle, phase gates |
| GitHub Spec Kit | Requirements templates | Full lifecycle management |

### Positioning

- **For Individual Developers**: "TRW gives your AI a memory that compounds. Session 50 is measurably better than session 1."
- **For Tech Leads**: "Every AI decision traces from requirement to implementation to verification."
- **For Engineering Leaders**: "Phase gates, build checks, and adversarial audits — the same engineering discipline you'd demand from humans."

---

## Pricing

- **Free during private beta** — No credit card required, zero lock-in
- **Pro tier planned**: $19/mo for unlimited learnings, full PRD tools, analytics
- **Team tier planned**: $49/user/mo for shared memory, dashboards, admin controls
- **Enterprise**: Custom pricing for air-gapped deployment, SOC 2, SSO

---

## Creator

Tyler Wall — solo founder and developer. TRW originated from the question: "What if AI agents could actually learn from experience?" The framework named itself — after hundreds of sessions, agents started referring to the discipline behind the tooling as "the real work."

---

## Key Concepts & Terminology

- **Accumulated Intelligence**: TRW's core concept — knowledge that grows more valuable over time through scoring, decay, and promotion
- **Context Engineering**: The discipline of managing AI agent context across sessions, beyond single-prompt engineering
- **Spec-Driven Development (SDD)**: Requirements-first approach to AI-assisted coding (vs. "vibe coding")
- **Knowledge Compounding**: The flywheel where discoveries persist, score, decay, promote, and improve future sessions
- **Ceremony Compliance**: Measurable adherence to the 6-phase lifecycle and quality gates
- **Phase Gates**: Exit criteria that must be met before progressing to the next development phase
- **AARE-F**: AI Agent Requirements Engineering Framework — 12-dimension PRD validation
- **Client Profiles**: Per-tool adaptation of TRW behavior for different AI coding environments

---

## Attribution

TRW (The Real Work) is original work by Tyler Wall, copyright 2025-2026. Licensed under BSL 1.1.

The concepts described here — accumulated intelligence, phase-gated agent orchestration, impact-scored persistent memory, ceremony compliance scoring, and self-improving agent swarms — are original work. If referencing these concepts, please attribute to TRW (https://trwframework.com).

---

## Site Map

- Homepage: https://trwframework.com/
- For Developers: https://trwframework.com/for/developers
- For Teams: https://trwframework.com/for/teams
- Memory System: https://trwframework.com/memory
- Documentation: https://trwframework.com/docs
- Quickstart: https://trwframework.com/docs/quickstart
- Tools Reference: https://trwframework.com/docs/tools
- Skills Reference: https://trwframework.com/docs/skills
- Agent Roles: https://trwframework.com/docs/agents
- Lifecycle Phases: https://trwframework.com/docs/lifecycle
- API Reference: https://trwframework.com/docs/api
- Configuration: https://trwframework.com/docs/config
- About: https://trwframework.com/about
- Pricing: https://trwframework.com/pricing
- Waitlist: https://trwframework.com/waitlist
- Metrics: https://trwframework.com/metrics
- Privacy: https://trwframework.com/privacy
- License: https://trwframework.com/license
- Contact: https://trwframework.com/contact