Start here / under ten minutes
Install the complete local stack, scan a repository, then explore the same graph in the TUI or hand it to your agent.
git clone https://github.com/UnboundCompute/lachesis-ui cd lachesis-ui && ./scripts/install.sh export PATH="$HOME/.lachesis/bin:$PATH" ~/.lachesis/build-graph.sh ./your-repository lachesis-ui
For headless use, install lachesis-cpg and set ATROPOS_ROOT to a reviewed catalog checkout or pack. Prefer a prebuilt interface? Download the TUI release.
Choose the job
The same Lachesis evidence can meet you where you work. Pick the smallest surface that gets you to a first result; add the others when the workflow earns them.
Explore a repository locally
Use the binary-first complete installer. It provisions the engine, Atropos catalog, graph helper, doctor, and TUI without requiring Go.
Install the local stack →Put evidence in every PR
Run the Action on your own runner and upload SARIF to Code Scanning. It is account-free; hosted inline comments are an explicit optional path.
Add account-free SARIF →Give an agent the graph
Connect an MCP-capable editor or agent with the PyPI/uvx package or the GHCR image. Keep source mounted locally and inspect the same witnesses.
Connect over MCP →The projects
Two projects make up the open foundation: Lachesis reads the code, Atropos says what is dangerous. The Action turns the same evidence into CI artifacts, and the TUI is the local expert surface. Use the foundation directly, then choose the surface that fits your workflow. Countermand is separate, also open, but a different tool for a different job.
A compiler-precise code property graph you can ask questions of: who calls this, what flows into this buffer, does this input reach that sink, which of two near-identical functions checks its input and which does not. It parses with real compilers, so it never loses a caller to a rename or an import indirection, and it serves the whole graph to an agent over the lachesis MCP server. It also ships as a GitHub Action, so the same analysis runs on every pull request and reports into code scanning.
The knowledge of what is a source, what is a sink, and what actually sanitizes, kept as plain validated JSON instead of buried in engine code. It is the model layer Lachesis reasons over, so anyone can review or extend it without touching the compiler.
Also open, separate projects
An action firewall for AI agents. Before an agent can do anything real, call a tool, hit an API, touch a file, it has to pass through the policy engine. It grew out of the guardrails we needed for our own agents, and it works with Claude Code, Codex, and any MCP client.
Our security-testing method, written as portable agent skills: playbooks for white-box bug hunting, AI-agent and LLM red-teaming, cloud and CI/CD trust, supply-chain risk, and appsec depth. Each one encodes the judgment behind a real test, not a script, so it transfers to any agent runtime. Install the whole set as a Claude Code plugin, or read one SKILL.md and run the loop by hand.
Choose your surface
One graph, three practical ways to use it: local CLI and MCP for exploration, a keyboard-driven TUI for navigation, or CI artifacts for review and policy.
The shortest complete path provisions Lachesis, Atropos, and the TUI together. The same stack can then serve a graph to an agent over MCP.
git clone https://github.com/UnboundCompute/lachesis-ui cd lachesis-ui && ./scripts/install.sh export PATH="$HOME/.lachesis/bin:$PATH" ~/.lachesis/build-graph.sh ./my-project lachesis-ui
How we build
A few habits run through all of it. They are why the code is worth reading, not just running.
A result only counts when there is hard, repeatable evidence behind it. The tools carry the same rule. Every edge in the graph states its confidence and where it came from, so you can tell a fact from a safe guess.
What counts as dangerous changes often, so it lives as validated data in Atropos, apart from the engine that reads it. Anyone can inspect or extend the model without reading a line of the compiler.
Our browser tools are single self-contained files you can read before you run them. The libraries hold the same line: small surfaces, honest confidence, and nothing you cannot inspect.
We build autonomous systems, so we build the brakes too. Countermand is the firewall our own agents pass through before they touch anything real, released so yours can use it as well.
Star a repo, open an issue, or tell us what you want to see next. It all lives under one organization.
Browse the org on GitHub →