Show HN: Lain, a structural code graph and agent coordinator for coding agents

Structural Code Intelligence & Multi-Agent Coordination for AI Assistants. Give your coding agents an in-memory graph brain instead of making them guess from flat text.

LAIN is a persistent, high-performance code intelligence and coordination engine built specifically for AI coding agents (Claude Code, Cursor, Copilot, Codex, Agy, Cline, Windsurf, etc.) over the Model Context Protocol (MCP).

Instead of treating code as unstructured flat text or relying on fuzzy keyword searches, LAIN indexes your codebase into an in-memory, typed structural property graph (using Tree-sitter, language servers, and Git commit history). It then exposes a rich suite of deterministic MCP tools that allow AI agents to navigate, reason about, and modify complex codebases without hallucinations, blind edits, or context-window waste.

• Instant Answers : Federation overview, repo health, and call graphs answered in milliseconds.
• Hot Reload : Editrepos.yaml orworkspaces.yaml ; the server updates live without dropping a single active MCP session.
• Interactive Tool Console : Exercise any MCP tool directly from the web browser;Copy as cURL gives agents and operators instant reproducibility.

Note

The demo is kept as a single GIF so it plays inline without storing duplicate video encodings in the repository.

flowchart TB
    subgraph Clients["AI Agents & Developers"]
        A["AI Coding Agent<br/>(Claude Code / Cursor / Agy / Codex)"]
        B["Developer / Operator<br/>(Browser Command Center)"]
    end

    subgraph Transports["MCP & Web Transports"]
        S["stdio (single-repo)"]
        H["HTTP :9999 (JSON-RPC & SSE)"]
    end

    subgraph Core["LAIN Core Engine"]
        EX["Unified MCP Tool Dispatcher"]
        G["In-Memory Graph Engine<br/>(Petgraph · UUID v5)"]
        PRES["Presence & Claim Registry<br/>(Advisory Leases & Locks)"]
        FED["Federation Engine<br/>(N Repositories)"]
    end

    subgraph Sources["Code Analysis & Storage"]
        TS["Tree-sitter AST Parser"]
        LSP["Language Servers (rust-analyzer, pylsp...)"]
        GIT["Git Commit History (Co-change radar)"]
        BIN[".lain/graph.bin (Persistent Cache)"]
    end

    A -->|MCP JSON-RPC| S
    A -->|MCP HTTP| H
    B -->|GET /| H
    S --> EX
    H --> EX
    EX --> G
    EX --> PRES
    EX --> FED
    G <--> BIN
    G --> TS
    G --> LSP
    G --> GIT

1. Indexing & Parsing : LAIN scans your code using Tree-sitter and language servers (LSPs), extracting functions, classes, imports, and references into a property graph.
2. Persistent Graph Store : The graph is serialized into.lain/graph.bin using deterministically derived UUID v5 identifiers for instant reloads.
3. Temporal Mining : LAIN analyzes git commit logs to build aco-change coupling radar (identifying modules that evolve together even without explicit imports).
4. Advisory Presence : In-memory and on-disk occupancy registries track agent sessions and file claims, preventing overlapping edits in real time.
5. Universal MCP Delivery : Exposes standardized tools over stdio or HTTP so any MCP-compatible agent can query the graph directly.

LAIN provides specialized MCP tools categorized by capability:

• get_blast_radius — Downstream impact analysis: every function, type, and file affected by changing a symbol.

• get_call_chain — Shortest path between two functions in the call graph.

• trace_dependency — All upstream dependencies (callees, imports, types) of a target symbol.

• get_coupling_radar — Files that frequently change together based on Git commit co-occurrence.

• find_anchors — Identifies the core architectural pillars (most-called, most-stable symbols).

• list_entry_points — Discovers main() , HTTP routes, and event handlers.

• get_context_depth — Measures abstraction distance from public entry points.

• explore_architecture — High-level hierarchical module and package tree.

• register_agent / heartbeat — Registers an agent session and keeps advisory leases fresh.

• claim_files / release_files — Claims or releases files and symbol ranges before editing.

• detect_overlap — Analyzes overlapping symbol changes between git branches or concurrent sessions.

• list_active_agents / who_am_i — Discovers other active agents and reports session identity.

• semantic_search(requires ONNX model — see Setting Up Semantic Search) — Concept-based code search using local ONNX embeddings with hybrid BM25/stemmed ranking.

• query_graph — Composable JSON ops pipeline ( find ,connect ,filter ,semantic_filter ,sort ,limit ).

• explain_symbol — Complete structural dossier for a symbol (signature, callers, docstring, location).

• list_repos / get_repo_info — Status, health, and size of all repos registered in repos.yaml .

• get_federation_health — Aggregate health counts, total node/edge counts, and a rough memory estimate across the federation.

• get_cross_repo_blast_radius — Cross-repository impact analysis when modifying a shared symbol.

• get_cross_repo_blast_radius_for_repo — Same as get_cross_repo_blast_radius , but the caller disambiguates the target repo byrepo_id instead of by symbol resolution.

• search_org — Organization-wide symbol and code search across all registered repositories.

• find_dead_code — Detects unreachable functions and unused symbols (excluding traits and tests).

• suggest_refactor_targets — Identifies brittle code (high-coupling, low-stability candidates).

• get_agent_strategy — Retrieves operational guidelines and strategic instructions for agents.

• get_world_state — Summarizes active sessions, file claims, and graph freshness in a single compact call.

curl -fsSL https://raw.githubusercontent.com/spuentesp/lain/main/install.sh | bash

source ~/.zshrc   # or ~/.bashrc
lain --version

See QUICKSTART.md for Homebrew, manual builds, non-interactive flags, and ONNX model setups.

claude mcp add lain -- lain mcp
lain setup --agent cursor

Writes ~/.cursor/mcp.json (the file Cursor reads directly). Windsurf shares the same config schema, so this command works for Windsurf too.

lain setup --agent vscode

Writes .vscode/mcp.json if it exists (project-scoped) or mcp.json in your user-config dir otherwise. Details in docs/COOKBOOK.md.

lain setup --agent codex     # uses `codex mcp add` when the CLI is on PATH
lain setup --agent continue  # writes ~/.continue/config.json
lain setup --agent generic

Writes .mcp.json at the workspace root. See docs/COOKBOOK.md for the exact schema.

Run LAIN as a shared service across multiple repositories:

lain server --config ./repos.yaml --transport http --port 9999

Access the Command Center UI in your browser at http://localhost:9999.

When lain server runs with --transport http, it serves the Command Center dashboard at GET /. It is a self-contained single-page application (SPA) that talks back to the running server over the same MCP JSON-RPC protocol.

• Overview — Real-time node/edge stats, memory footprint, and federation health.
• Graph — Interactive D3 force-directed visualizer of workspaces and symbol dependencies.
• Repos — Repository table showing health, path, and node/edge statistics.
• Query — Interactive query runner forquery_graph traversals.
• Tools — Form-based MCP tool runner with auto-generatedCopy as cURL snippets for quick testing.

LAIN exposes the following CLI commands:

lain server monitors repos.yaml and workspaces.yaml and automatically updates its federation state when they change—without restarting the process or dropping active agent connections. Both manual file edits and CLI commands (lain repos add ...) communicate over a local Unix socket (~/.local/lain/run/<repos-stem>.sock) to rebuild the index diff atomically.

See docs/hot-reload.md for full operational details.

For semantic_search, download an ONNX embedding model (or run install.sh --download-model):

mkdir -p .lain/models

curl -L https://huggingface.co/BAAI/bge-small-en-v1.5/resolve/main/onnx/model.onnx \
  -o .lain/models/model.onnx
curl -L https://huggingface.co/BAAI/bge-small-en-v1.5/resolve/main/tokenizer.json \
  -o .lain/models/tokenizer.json

export LAIN_EMBEDDING_MODEL=$PWD/.lain/models/model.onnx

For BGE-style asymmetric retrieval (optimized for short natural-language queries), configure the prefix in .lain/tuning.toml:

query_prefix = "Represent this sentence for searching relevant passages: "

Note: If no embedding model is configured, semantic_search is filtered out of tools/list automatically so agents are never presented with an unusable tool. All graph, blast radius, navigation, and coordination tools function without an ONNX model.

• First-time setup issues? SeeQUICKSTART.md § First aid .
• Run diagnostics :lain doctor reports repository and MCP readiness without changing files;lain doctor --json emits the same result for scripts and agents.
• Hand-edit not picked up? The hot-reload watcher is non-recursive and uses atomic rename. Editing the file in place (vim repos.yaml ) triggers a notify event within ~1 s. If you moved the file across directories, save it back into the project directory.
• Repo stuck in indexing / degraded / unavailable? The Command Center Overview tab displays these metrics live.

curl -s -X POST http://localhost:9999/mcp \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"get_federation_health","arguments":{}},"id":1}'

• run_build / run_tests fail with "not found"? Editor-launched MCP servers inherit environments that lack version-manager shims (rustup, nvm, pyenv, volta, asdf). LAIN searches known install locations automatically; to configure custom managers, seetoolchains/README.md .
• Answers look stale, or a symbol "doesn't exist" that clearly does? Checkget_health :
  • Build: shows the binary version and git SHA. MCP stdio processes are spawned once by the client and outlive source rebuilds; restart your editor/client to pick up a newly built binary.
  • Status: Degraded ⚠ indicates indexing timed out. SetLAIN_REINDEX_TIMEOUT=600 (defaults to 300s outer, 60s per-repo) to accommodate large working trees on cold cache.
• Two agents not seeing each other? Verify they share the same workspace. State is persisted under~/.local/lain/state/ , andlist_active_agents confirms shared visibility.
• Force re-indexing : Callrequest_reload via MCP or touchrepos.yaml .

The hero demo recording in docs/screenshots/ can be re-recorded after UI changes:

make record-demo

Or run npm run record-demo --prefix tests/js for the Playwright driver (and scripts/record-spa-demo.sh for ffmpeg encoding). For offline fixture testing, run make record-demo-small.

MIT — Copyright (c) 2026 spuentesp