Overview

The problem

AI coding agents ship fast, but each one makes its own architectural choices — silently, differently, every time. The diffs look fine in isolation. Six months later you have a codebase that works but has no coherent design, and no one can explain why anything is the way it is.

The system works. You just don’t own it.

What Trurlic does

Trurlic makes you the architect again. Architectural decisions live in a typed graph inside your repo, and every agent receives them as hard constraints before generating code — served over MCP. One decision graph, every agent follows it, nothing slips through.

   You              AI coding agent
    │                     │
    │ CLI: init,          │ MCP: pull context,
    │ inspect, maintain   │ design, record, verify
    ▼                     ▼
  ┌───────────────────────────────────┐
  │  .trurlic/  —  decision graph      │
  │  git-tracked TOML, one source      │
  │  of truth for every agent          │
  └───────────────────────────────────┘

The CLI writes and inspects the graph; the agent reads and writes it over MCP. Trurlic is the shared layer between them.

What the agent sees

When an agent calls get_context("rate-limiter"), Trurlic returns an authoritative brief:

RULES (inviolable — every generated line must respect these):
- ALL error handling MUST use Result<T, AppError>
- ALL persistent state MUST use Redis

COMPONENT: rate-limiter
- Per API key, consistent with auth boundary
- Redis sliding window, 60s buckets
- 429 + retry-after header, RFC 6585 compliant

PATTERNS:
- state-in-redis: shared pool via app state, no per-component connections

RELATED (from connected components):
- auth: JWT with DPoP, rate limiter runs AFTER auth

OVERRIDE POLICY:
RULES are inviolable. Component decisions are strong defaults — follow them
unless the user explicitly revises them. Never silently deviate.
WHEN UNCERTAIN: STOP and ask.

Every decision came from a human decision or a reviewed agent proposal. The agent generates code; the graph constrains it.

Three guarantees

Decisions are human-owned. Every constraint traces to a person — a design conversation, a trurlic decide command, or explicit review of an agent-proposed decision. Agent-recorded decisions land flagged agent · unreviewed until you promote or revise them.

One graph, every agent. Claude Code, Cursor, Copilot, Codex, or a custom agent — they all query the same graph over MCP. No configuration drift between tools.

Fail-closed on writes. Every mutation validates the full graph before touching disk. Dangling edges, cycles, schema violations — refused with a clear error, never silently committed.

What Trurlic is not

• Not a linter. It constrains what gets generated, upstream of code — not what already exists.
• Not a prompt template. The graph is structured, typed, validated, and queryable — not a markdown file pasted into context.
• Not a governance gate. It provides constraints; it does not approve or deny agent actions. For execution-level enforcement, see LatchGate.

When to use it

Reach for Trurlic when multiple AI agents need architectural consistency, when decisions must survive developer and agent turnover, or when “why was this built this way?” needs a real answer. Skip it for solo prototypes and pure config where consistency doesn’t matter yet.

Next

Getting Started to install · Core Concepts for the model · MCP Server to connect an agent.