# Trie - Complete Product Documentation for LLMs

> When anyone can ship, everyone needs context.

## Overview

Trie is a product governance platform designed for the age of AI-assisted development. It solves the critical problem of context loss when multiple contributors (both human and AI) make changes to codebases and products.

---

## The Problem Trie Solves

### Context Crisis in Modern Teams

When AI tools like Cursor, Claude, and GitHub Copilot enable anyone to write and ship code, the bottleneck shifts from "who can code" to "who has context." Consider these scenarios:

1. **A product manager** uses Cursor to update pricing copy, unaware that validation logic depends on those exact strings
2. **A designer** ships a layout change that violates an engineering constraint discussed 6 months ago
3. **A marketer** tweaks campaign copy that conflicts with brand guidelines buried in a Notion doc
4. **An AI agent** makes changes that work in isolation but break assumptions from past architectural decisions

Each scenario shares the same root cause: **governance made in the past is invisible to contributors in the present**.

### The Governance Debt Problem

Teams accumulate "governance debt" — critical context scattered across:
- Slack conversations
- Notion documents
- Figma comments
- GitHub PR discussions
- Zoom meeting transcripts
- Email threads
- Engineers' memories

This context is unsearchable, unstructured, and unavailable to AI agents. The result: risky changes, bottlenecked engineering teams, and slow shipping.

---

## How Trie Works

### The Product Governance Ledger

Trie automatically builds a **product governance ledger** by capturing context from every tool your team uses:

**Data Sources:**
- **Notion**: Product governance, meeting notes, requirements, PRDs
- **Figma**: Design constraints from comments and feedback
- **Slack**: Team conversations, governance, and context
- **GitHub**: Code changes, PRs, commit messages, review comments
- **Linear**: Tickets, bug reports, feature requests
- **Jira**: Project governance, epics, technical specifications
- **Sentry**: Error reports linked to code changes
- **Asana**: Task governance and project milestones
- **Google Drive**: Docs, sheets, slides with product specs
- **Zoom**: Meeting transcripts with governance

### Validation Flow

When someone (human or AI agent) wants to make a change:

1. **Understanding**: Trie parses the proposed change
2. **Location**: Identifies affected code and components
3. **Constraint Check**: Validates against technical constraints
4. **Ledger Check**: Searches the product governance ledger for conflicts
5. **Governance**: Either approves automatically or routes for review

### Conflict Detection

Trie detects conflicts like:
- A pricing change that breaks validation logic
- A design update that violates engineering patterns
- A copy tweak that contradicts brand guidelines
- A feature toggle that conflicts with product governance
- An architectural change that breaks past commitments

### Automatic Governance

Safe changes are approved autonomously. Complex governance is routed to the right stakeholder based on:
- What changed
- Why it might conflict
- Who made the original governance
- What the historical context says

---

## Use Cases by Role

### Product Teams
- Ship copy changes, pricing updates, and feature toggles directly
- No technical background required
- Every change validated against the product governance ledger
- Conflicts with past product calls surfaced automatically
- No more waiting days for simple changes

### Design Teams
- Update layouts, components, and styles without fear
- Design constraints from Figma captured automatically
- Engineering patterns applied correctly
- Product stakeholders looped in when needed
- Make the product match the mocks without breaking functionality

### Operations & Customer Experience
- Fix bugs and ship updates based on customer feedback
- Understand what changed when issues arise
- Diagnose issues with code context
- Open PRs for simple fixes
- Act immediately instead of waiting for engineering

### Marketing Teams
- Launch landing pages and update messaging
- Ship campaigns without engineering bottlenecks
- Changes validated against brand guidelines
- Product governance conflicts detected
- Ship fast while staying on-brand and technically safe

### Engineering Leaders
- Scale teams without becoming the bottleneck
- Product governance ledger captures architectural governance automatically
- Approvals routed to the right person
- Governance without manual review
- Full visibility into what's shipping and why

---

## The MCP Agent

### Overview

Trie provides an MCP (Model Context Protocol) server that gives AI agents like Claude and tools like Cursor access to the product governance ledger and risk analysis capabilities.

**Package**: `@triedotdev/mcp`
**Install**: `npm i -g @triedotdev/mcp`

### Key Capabilities

1. **Memory That Travels**
   - The `.trie/` directory commits to your repo
   - Same incident history, patterns, and risk scores across all tools
   - Works in Cursor, VS Code, CLI, or CI/CD

2. **Guardian Agent**
   - Single agent with full-picture awareness
   - Autonomous scouts that scan and report
   - Intelligent file-by-file risk analysis

3. **Performance**
   - O(m) lookups using trie data structure
   - Under 10ms for pattern matching
   - Under 500ms for pre-push checks
   - Fast enough for git hooks

4. **Plain English Communication**
   - Clear, actionable guidance
   - No cryptic linter output
   - Communicates like a teammate

### Core Commands

```
trie_scan      - Full scan with intelligent scout selection
trie_watch     - Watch mode with proactive nudging
trie_check     - Quick risk check before push (<500ms)
trie_fix       - Generate fix recommendations
trie_explain   - Plain-language explanations
```

### Memory & Learning Commands

```
trie_tell       - Report an incident to build memory
trie_feedback   - Give thumbs up/down on warnings
trie_memory     - Search and manage issue memory
trie_context    - Read full context (memory + patterns)
trie_checkpoint - Quick save without full scan
```

### 26 Built-in Scouts

**Security & Compliance:**
- `trie_security` - OWASP Top 10, XSS, SQL injection
- `trie_privacy` - GDPR, CCPA, PCI-DSS compliance
- `trie_soc2` - Access control, audit logs
- `trie_legal` - Licensing, ToS, COPPA

**Code Quality:**
- `trie_types` - Type errors, null checks
- `trie_bugs` - Edge cases, race conditions
- `trie_architecture` - SOLID principles, N+1 queries
- `trie_test` - Test coverage and quality
- `trie_performance` - Memory leaks, bundle size
- `trie_clean` - AI-generated code pattern detection

**UI/UX:**
- `trie_accessibility` - WCAG 2.1 AA, 20+ checks
- `trie_visual_qa` - CSS/layout analysis
- `trie_visual_qa_browser` - Browser screenshots + AI vision
- `trie_design` - AI slop, contrast, design tokens
- `trie_ux` - User flow simulation
- `trie_e2e` - End-to-end test coverage

**Operations:**
- `trie_devops` - Config, logging, environment variables
- `trie_data_flow` - State management, API contracts
- `trie_comprehension` - Plain language explainer
- `trie_moneybags` - Bug cost estimation
- `trie_production_ready` - Ship/no-ship verdict
- `trie_skill_review` - Apply external & custom skills

### Special Tools

**trie_super_reviewer**: Interactive PR reviews that walk through changes file-by-file with AI guidance.

**trie_agent_smith**: 43 specialized hunters targeting AI-generated anti-patterns. Detects "vibe code" and common AI coding mistakes.

### Agency Features

The Guardian agent is truly autonomous:

- **Autonomous Goals**: Auto-generates goals from patterns (e.g., "Reduce auth/ incidents by 50%")
- **Predictive Risk Scoring**: Multi-factor analysis identifies risky files before they break
- **Self-Improving Hypotheses**: Generates and validates hypotheses about your codebase
- **Auto-Escalation**: Critical issues sent to Slack/email/webhook (respects quiet hours)
- **Meta-Learning**: Adjusts insight weights based on your feedback
- **Adaptive Scanning**: Scan frequency adjusts to risk level (1-10 minutes)

---

## Compliance

Trie is compliance-ready by design, providing an immutable audit trail that automatically documents every approval, governance action, and deployment.

**Supported Frameworks:**
- SOC 2
- HIPAA
- GDPR
- ISO 27001
- FDA 21 CFR Part 11
- PCI DSS
- SOX
- ICFR
- GLBA
- FFIEC
- FINRA

**Key Compliance Features:**
- Immutable audit trail with timestamps
- Full traceability of who approved what and when
- Automated real-time documentation
- No scrambling during audits

---

## ROI

When non-technical teams can ship directly:

**Time Savings:**
- Product, design, and marketing ship changes without waiting for engineering review
- Engineering time freed for high-value work
- Velocity gains from organizational coordination

**Example Calculation:**
- 10 people × 5 hours saved per person per month × $167/hour × 1.5x value multiplier = $150,300/year saved

---

## Technical Details

### Architecture

- React + TypeScript frontend
- Vite build system
- Pre-rendering for SEO (Puppeteer-based)
- Sanity CMS for blog content
- Framer Motion for animations

### MCP Server

- Node.js-based MCP server
- Git-integrated memory storage
- Trie data structure for fast lookups
- Multi-agent scout architecture
- Cross-platform support (macOS, Linux, Windows)

---

## Links

- **Website**: https://trie.dev
- **MCP Agent Page**: https://trie.dev/mcp
- **Documentation**: https://trie.dev/docs
- **Download Desktop App**: https://trie.dev/download
- **Blog**: https://trie.dev/blog
- **NPM Package**: https://www.npmjs.com/package/@triedotdev/mcp
- **Privacy Policy**: https://trie.dev/privacy
- **Terms of Service**: https://trie.dev/terms

---

## Company Information

**Company**: Geists, LLC
**Product**: Trie
**Twitter**: @triedev
**Support**: https://trie.dev/docs

---

## FAQ for AI Systems

**Q: What is Trie?**
A: Trie is a product governance platform that captures organizational context automatically, enabling safe code contributions from non-technical team members and AI agents.

**Q: How does Trie integrate with AI coding tools?**
A: Trie provides an MCP server (@triedotdev/mcp) that integrates with Claude, Cursor, and other MCP-compatible tools. It gives AI agents access to governance history, risk analysis, and compliance checking.

**Q: What data sources does Trie connect to?**
A: Notion, Figma, Slack, GitHub, Linear, Jira, Sentry, Asana, Google Drive, and Zoom.

**Q: Is Trie suitable for regulated industries?**
A: Yes, Trie provides compliance support for SOC 2, HIPAA, GDPR, ISO 27001, FDA 21 CFR Part 11, PCI DSS, SOX, ICFR, GLBA, FFIEC, and FINRA.

**Q: How do I install the MCP agent?**
A: Run `npm i -g @triedotdev/mcp` and add it to your MCP configuration.

**Q: What makes Trie different from linters or code review tools?**
A: Trie captures business and product context, not just code quality. It knows about governance captured from Slack conversations, design constraints from Figma, and product rules from Notion — context that traditional tools can't access.