SourceAnt

Software intelligence for you and your coding agents.

SourceAnt connects your code, the services it depends on, and the decisions behind it. Bring that context into your agents’ work and your code reviews, so the next change builds on what your team already knows.

Get started See it in action

Flat $49 a month, every engineer and every agent included · Your own model keys · On-premise available

What your system is actually made of

The parts read out of your code, then the same system as a diagram: what provides what, and what depends on it.

Explore systems

An example: changing payment retries

A decision remembered. A conflict caught.

  1. 1. Keep the decision

    The mobile client owns the payment key.

    Record why: reusing the same key lets a payment retry without creating a second charge.

  2. 2. Connect the code

    The client and payment service share that contract.

    Link the decision to both sides, even when they live in separate repositories.

  3. 3. Review with that knowledge

    A new key on every retry breaks the agreement.

    The review can point to the recorded decision and the affected client, so the author knows what to preserve.

A ten-engineer team pays $49, not $290 Agent-native, over MCP Your own model keys Human-governed knowledge
curl -fsSL https://raw.githubusercontent.com/sourceant/cli/main/scripts/install.sh | sh

The daily reality

AI made code cheap to write and expensive to trust.

On a large, critical codebase, velocity now outruns anyone’s ability to hold the architecture in their head, judge a change against the real system, and ship it safely.

  • The why lives in your team’s heads

    Agents open more changes in a day than your senior engineers can trace back to the decisions behind them. The reasoning that keeps the system correct never made it out of a Slack thread or a closed PR.

  • The system outgrows anyone’s grasp, and quietly drifts

    It gets bigger and more AI touches it, until no one holds the whole shape anymore. It keeps changing in a direction nobody deliberately chose, and you only notice once it is hard to undo.

  • Quality and reliability slip as you scale AI

    The more you ship with agents, the more workarounds get reverted, conventions drift, and contracts break. Trust in the codebase erodes right when you are moving fastest.

  • Your AI spend climbs and the context never sticks

    Every session re-explains the same architecture, burning tokens and per-seat fees, and none of it is captured for the next engineer or the next agent.

Teams that capture the why compound understanding with every change. Teams that do not ship faster into a system they understand less each week.

The thesis

A code graph tells an agent what the code is. Not what it is for.

Index a repository and you can answer where a symbol lives, who calls it, and what it imports. That is a solved problem, and we did not reinvent it: the code graph underneath SourceAnt is codebase-memory-mcp, which we build on.

It is also not enough to make a correct decision. Structure cannot tell an agent that the retry ceiling was set after an incident, that a service two repositories away consumes the contract it is editing, or that the regulator ruled out the obvious approach last quarter. None of that is in the code, so no parser can find it.

Everything above the graph is the part we had to build.

What the code is

Files, symbols, calls and imports. Built on codebase-memory-mcp, which does this well and openly.

What it is for

The decisions, constraints and conventions your team recorded, and the organisational rules that were never in a file at all.

What it connects to

The services, queues and datastores on the other side of the change, across repositories a single diff cannot see.

Whether it is still true

A status your team controls and a staleness mark, so a superseded rule stops being served as a current one.

One platform

One knowledge layer, many jobs on top

SourceAnt captures how your codebase works and serves it everywhere, so your tools and your team act on real understanding instead of skimming files.

Code graph

A map of your files, symbols and their relationships. See the structure an agent is changing, not just the lines in its diff.

Knowledge graph

What you know, or should know, about the code. Keep decisions, constraints and conventions after the session that found them ends.

System graph

Living architecture documentation. See how services and datastores connect, where the architecture is moving, and whether you want it to go there.

Requirements graph

What the software is supposed to do, linked to the code and tests that carry it. Premium requirements engineering builds on the local foundation.

The whole system

Capture the knowledge once. Put it to work everywhere.

One living map of how your system works: your team sees where it is heading and steers it, your agents build with the full context, and the jobs you rely on run on top.

Code knowledge management

Understand your own system, and keep your agents on it

SourceAnt captures the decisions, constraints, contracts, and conventions behind your code and structures them into a living map of how your system actually works, one that stays current as the code changes.

For your team

See how the system is built, how it is changing, and where it is heading, so you catch drift early and decide whether that is the direction you want before it is baked in.

For your agents

The relevant slice is served back over MCP the moment an agent acts, so it builds with the full why instead of guessing at it.

Context-aware review

Check each change against your real decisions and its blast radius, so the bugs that read fine and the workarounds it wants to delete get flagged before they merge.

Issue triage

Duplicate detection and intelligent auto-labeling on issues and PRs, so your backlog stays deduped and routed without hand-sorting.

Engineering analytics

See token usage and savings, review quality, context coverage, and triage stats, so you can watch reliability and AI spend as you scale.

Portable

Works with the tools you already use

SourceAnt speaks MCP, so your context and every application show up in whatever your team codes with. And it is not just for humans: agents query the knowledge headlessly, mid-task, without anyone re-pasting context. No lock-in, no new habits.

Claude Code
Cursor
Codex
Zed
VS Code
Any MCP client

Who it's for

For teams shipping fast with AI on code that cannot break

You run a large, critical codebase, you move at the pace of your agents, and you care as much about architecture and reliability as about velocity. You self-host, you want usage-based pricing and your own keys, and you need humans to keep understanding the system, not just the code.

The architect holding the why

You are the reason the system still hangs together. SourceAnt gets the decisions, constraints, and contracts out of your head and into a graph every tool and teammate can query, so the architecture survives the pace you are shipping at.

The platform lead who self-hosts

You run this on your own infrastructure, with your own keys, and you watch the AI bill. SourceAnt is open source, priced on what it analyses rather than on seats, and private by default, and it cuts tokens by serving only the slice a task needs.

The engineer on the hook

You are accountable when an agent’s change breaks production. SourceAnt judges each change against the real system and hands your tools the reasoning behind the code, so speed does not cost you trust.

How it works

A graph, not a pile of text

Capture the why, link it into a knowledge graph, and serve only the relevant slice to any AI tool the moment it acts.

1. Map the code

Index your repositories into one code graph, so you and your agents can follow symbols and relationships across the code being changed.

2. Keep your intent

Record the decisions, constraints and requirements the software must continue to respect. Link them to the code and system parts they govern.

3. Use it before each change

Give the relevant context to your tools over MCP and review agent changes before they reach your colleagues.

Files linked to the decisions and conventions that explain them

In practice

The decisions your agent would otherwise undo

An assistant reads the code in front of it. It cannot read the incident that set the retry limit, or the discussion that ruled out jitter. SourceAnt hands it both before it writes.

An assistant is asked

Refactor the payment retry logic to use exponential backoff.

src/payments/retry.ts

SourceAnt answers with what that code already decided

Constraint from an incident review

Max retry stays at 3. Higher values caused duplicate charges once already.

Decision from a team discussion

Jittered backoff did not survive the rate limiter. The fixed delay is deliberate.

Contract from the mobile client

Idempotency keys are generated client-side. Changing that breaks the mobile app.

It ships the backoff and leaves the retry ceiling, the fixed delay, and the idempotency key where they are.

Served over MCP, so this works in whichever assistant your team already uses.

Illustrative example

The other direction

The session ends. What it taught you does not have to.

Most of what keeps a system correct is worked out mid-task and then lost when the window closes. SourceAnt gives your agent somewhere to put it, over MCP, in the tool you are already in.

/remember

Save what you just worked out

You find out why the fixed delay is deliberate. One command and it is a constraint on that code, available to the next session and the next engineer.

/context

Ask what this code already decided

Before touching a file, pull the decisions, constraints and contracts that govern it, rather than inferring intent from the lines in front of you.

/review

Get reviewed before you push

Review the work in your checkout, uncommitted and unpushed, against the same graph a pull request would be judged by.

It is not only about code. A rule about what may never go in an analytics event, a constraint a regulator put on you, a convention two teams agreed in a meeting: none of that is in a file, so a tool that parses files has nowhere to put it. A knowledge record here has no repository field and no file field, which is what lets it hold the things your codebase never wrote down.

Systems & cross-repository reviews

How the review knows your frontend is about to break

SourceAnt reads the manifests your repositories already publish, proposes how the parts depend on each other, and waits for a person to approve. That map is what a review walks: change a contract here and it goes and reads the service that consumes it over there. When a part stops matching the code it is marked stale rather than left quietly wrong.

A repository it could not read is named, not skipped.

Every proposal is pending. Nothing here approves itself.

Every edge names the file it was read from.

A part that has aged is flagged, not silently believed.

How cross-repository review works See the use cases
A software system in SourceAnt showing its services, datastores, and the relationships between them, with pending proposals waiting for approval

Why SourceAnt

Why not comments, ADRs, a vector database, or another per-seat review bot?

Structured, not prose. Context is typed and linked in a graph, so tools retrieve the exact slice instead of grepping comments that have gone stale.

Governed, not hallucinated. Knowledge carries a status your team controls and your tools filter on: approval marks what the team vouches for, and it never queues capture behind a person. A vector store just guesses.

Portable and private. Served over MCP to any tool, open source you can self-host, with your own model keys. Your knowledge and your AI spend stay on your side, never in a vendor’s silo.

Priced for how you actually work. Usage-based and bring-your-own-key, one flat team price, no per-seat AI tax as you add engineers or agents.

How SourceAnt compares to Sourcegraph and graphify

Review the whole system, not one diff

One flat fee from $49 a month, with your own model keys. Every engineer and every agent you have, for the same price. On-premise if your code cannot leave your network.

1. Connect your repos 2. Approve what it captures 3. Everyone ships with the why
Start free Read the docs