scryer

MDD for AI agents.
Scryer is a visual C4 modeling tool where you and your AI agent work from the same architecture model.

Features   •   Getting started   •   MCP server   •   Building from source   •   Docs

AI agents can write code, but what you describe and what gets implemented tends to drift. Scryer gives you a shared visual model: you edit it in a drag-and-drop editor, the agent reads and modifies it through MCP. Once the model looks right, the agent generates code from it — get_task feeds work one unit at a time with dependency ordering, inherited contracts, and progress tracking.

Works with Claude Code and Codex out of the box. Any agent that supports MCP can read and write models. Agents that support ACP can also be spawned by Scryer for automated sync.

Opinionated C4 hierarchy (system, container, component, operation/process/model), typed relationships, behavioral flows, contracts.

• C4 Architecture Diagrams
  • Drag-and-drop editor for systems, containers, components, and operations. Drill down through levels.
  • Code-level nodes (operations, processes, models) show in a compact list view.
• Behavioral Flows
  • Model user journeys, data pipelines, deploy sequences. Supports branching and decision points.
  • Flows serve as integration test specs — link them to test files via source mapping.
• Contracts
  • Expect/ask/never rules that tell AI agents how to implement your code. Inherited down the hierarchy.
  • Expect items have pass/fail flags that control when a node can be marked "ready".
• Status Tracking
  • Three statuses: proposed (planned), wip (code exists), ready (verified).
  • During implementation, agents mark nodes as wip. "Ready" is a separate verification step — the implementation must be complete (no stubs or TODOs), existing tests must pass, and all expect contract items must be satisfied.
• Source Mapping
  • Link architecture nodes to files in your codebase with file patterns and line ranges.
  • Click to open in your editor.
• MCP Server
  • AI agents connect to read, modify, and build from your architecture model in real-time.
• Drift Detection & Sync
  • Scryer tracks when source files change relative to the model. When drift is detected, click sync to have Scryer spawn the connected agent to update the model.
• AI Advisor
  • Optional LLM-powered review that flags structural issues in your diagrams. Supports OpenAI, Anthropic, Google, Groq, Mistral, DeepSeek, and Ollama.
• Implementation Workflow
  • get_task gives AI agents one piece of work at a time, ordered by dependencies, with contracts inherited from parent nodes. Build, mark wip, repeat.
• AI Tool Setup
  • Detects Claude Code and Codex, writes MCP config and auto-approve permissions for your project.

Download the latest release for your platform from the releases page.

1. Link your project directory in the app and enable AI tool integration when prompted (or run scryer-mcp init)
2. Tell your AI agent: "Use scryer to model this project's architecture"
3. The AI calls MCP tools — nodes appear in the visual editor in real-time
4. Review, drag things around, rename, remove, restructure
5. Tell the AI: "Implement this model"
6. The AI builds each piece one at a time, marking nodes as wip as it goes
7. When you're satisfied, ask the AI to verify: check for stubs, run any existing tests, and confirm contract items pass before marking nodes as ready

As you work on code, Scryer detects when source files drift from the model. Click the sync button to have Scryer spawn your agent to update the model.

Scryer is built to work with Claude Code and Codex first.

• MCP (Model Context Protocol) — how agents read and write architecture models. Required for any agent integration.
• CLI spawning — how Scryer launches agents for automated sync. Claude Code is spawned via claude -p (uses your subscription), Codex via codex exec (uses your API key). Both get the Scryer MCP server attached automatically.
• ACP (Agent Client Protocol) — for agents that implement the full ACP handshake (e.g. via claude-agent-acp). Scryer falls back to ACP if a {name}-acp binary is found on PATH.

When an agent connects via MCP, Scryer captures its identity from the protocol handshake. When sync is triggered, Scryer resolves that identity to a binary and launches it with the right flags. Claude Code and Codex are mapped automatically. For other agents, Scryer tries ACP conventions.

The MCP server lets AI agents read and modify your architecture models. It ships bundled with the desktop app.

Link a project directory in the app and click "Enable" on the prompt, or run scryer-mcp init from the command line. Both detect installed AI tools and write config:

• Claude Code — .mcp.json + read tool auto-approve in .claude/settings.local.json
• Codex — .codex/config.toml

Existing config files are preserved — only the scryer entry is added or updated.

If you prefer to configure MCP manually, add Scryer to your project config:

Claude Code (.mcp.json in project root):

{
  "mcpServers": {
    "scryer": {
      "type": "stdio",
      "command": "/path/to/scryer-mcp"
    }
  }
}

Codex (.codex/config.toml in project root):

[mcp_servers.scryer]
command = "/path/to/scryer-mcp"

For Claude Code, you can also auto-approve Scryer's read tools so the agent doesn't prompt for every get_model call. The app can set this up for you, or add them manually to .claude/settings.local.json:

{
  "permissions": {
    "allow": [
      "mcp__scryer__list_models",
      "mcp__scryer__get_model",
      "mcp__scryer__get_node",
      "mcp__scryer__get_rules",
      "mcp__scryer__get_changes",
      "mcp__scryer__get_structure"
    ]
  }
}

Reading:

• get_model — full model with all nodes, edges, flows, groups, source map. Name is optional — auto-resolves the model linked to the current working directory
• get_node — scoped read of a subtree with internal/external edges and context
• get_changes — diff against baseline (what changed since you last looked)
• get_rules — full C4 modeling rules and workflow guidance
• get_structure — annotated project directory tree (manifests, infrastructure, environments)

Implementation:

• get_task — next implementation task. When multiple containers are ready, presents a choice menu with groups. Scaffold tasks fire first for deployment groups. The model is the spec — agents must build exactly what it describes and clean up anything templates add that isn't in the model
• Add, update, and remove nodes and edges
• Define behavioral flows with branching (set_flows)
• Organize containers into groups (set_groups)
• Link nodes and flows to source code (update_source_map)
• Validate the model against C4 rules (validate_model)

Architecture models go stale as code changes. Scryer detects drift two ways: source-mapped nodes whose files changed since last sync, and new files appearing in the project that aren't covered by the model yet.

When drift is detected:

1. A sync bar appears at the bottom of the editor showing potentially drifted nodes — click any node name to navigate to it on the canvas
2. Click Sync to spawn your agent (Claude Code via claude -p, Codex via codex exec) with Scryer's MCP server attached. The canvas is locked during sync — cancel rolls back all agent changes
3. The agent receives a list of potentially drifted nodes, reads the changed source files, and updates the model only where code has actually diverged
4. Model changes appear in the editor in real-time. If nothing actually drifted, dismiss the notification to reset the baseline

For Claude Code, the MCP server config is passed inline via --mcp-config. For Codex, the project must have MCP already configured (via scryer-mcp init or the app's setup flow) since Codex reads MCP config from .codex/config.toml.

Scryer is a Tauri desktop app. The UI is written in React with TypeScript and the backend is written in Rust. Canvas rendering uses ReactFlow with d3-force for auto-layout.

• Rust (stable)
• Node.js 20+
• pnpm
• System dependencies for Tauri 2

If you use Nix, shell.nix provides everything:

nix-shell

pnpm install          # Install dependencies
pnpm tauri dev        # Run full app (Tauri + Vite on :1420)
pnpm dev              # Run frontend only
pnpm tauri build      # Production build

Scryer is Fair Source software under the Functional Source License (FSL-1.1-MIT). You can use it, view the source, and contribute. You just can't build a competitor with it. The license converts to MIT after two years.