Blast reviewer
Walks the live model from the changed node and writes the confidence-ranked comment a senior reviewer would have written. The PR knows what it might break before merge.
Every endpoint, every dependency, every event, cited to a repo and a commit. Auto-synced on a clock. The substrate humans navigate and agents act on, the same way.
Ask anyone what calls billing. They reconstruct it from grep. Ask an LLM and it invents an answer. The architecture diagram is wrong, the wiki is stale, the senior who knew is on PTO. The system as one object does not exist anywhere.
Every agent that touches your system is guessing, because every human that touches your system is guessing.
Your architecture diagram is for the system you wrote down. blastmap is the system that is in production. Read from real signals on a clock. Anchored to repos and commits. Hover any node for relationships. Click any node for the receipt.
A system is small units that should come together. Your repos. Your deploys. Your traces. Your bus. Your k8s state. Your dashboards. Your runbooks. Each one describes one fragment of the same system. None of them are connected to each other today. We do the connecting.
Extractors walk the live system. Traces, eBPF, the bus, the cluster, the manifests.
Every endpoint, event, consumer is anchored to a repo, a commit, and the extractor that found it.
The model resyncs continuously. The freshness stamp is on every edge. Stale answers do not pretend.
Prod, staging, dev, region by region. Same model, different reality. Drift is named, not hidden.
The map of your system is the most sensitive object your system has. blastmap runs in your network on your hardware. We do not host a SaaS that ingests your graph. We do not share your code with another customer. We do not see it ourselves.
Runs in your Kubernetes, your VPC, your bare metal. There is no cloud edition. There is no shared inference layer. There is no path by which your topology lands in our database.
The inference layer is your choice. Anthropic, OpenAI, Vertex, Bedrock, Ollama, a fine-tuned house model. The prompts and embeddings run wherever you tell them to run.
The extractors, the noisy-OR merge, the refusal logic, the scoring. All open source, all auditable. The thing you run is the thing you can read.
The model is not a static catalog. It is a live, verified map of how your system actually runs, plus a verified record of every fact about it. Read it three ways: through the assistant in-app, through MCP from any agent, or from code via the API.
An in-app chat over the model. Plain English in, cited evidence out. Backed by the same graph and the same confidence as everything else.
The Model Context Protocol surface. Claude, Cursor, Cline, any in-house agent gets 12 read-only tools over the live graph.
HTTP + SDK. Query the model from a script, a CI hook, a webhook handler. Every response carries provenance and confidence.
The same substrate that grounds agents grounds you. Plain English in, evidence out, every claim traceable to an extractor and a line. This is one question, fully resolved, in real time.
Every tool call is named, every result cites the extractor that produced it, every confidence is a real number from the merge. The model refuses to answer when the evidence is not there.
The conversation is one surface of the model. The other surfaces are agents doing the operational work end to end, with the same discipline.
The same answers, accessed by an agent instead of a human. Claude calls one of the 12 read-only tools, the model returns evidence with confidence, the agent composes a grounded reply. No invented edges, no false certainty.
Add blastmap from the Claude Code marketplace, or point Claude at your published graph over stdio or SSE. Twelve tools registered, ready to query, auth handled.
Every tool result carries provenance and confidence. The agent must rank and gate on it instead of pretending all knowledge is equal. Stale answers do not pretend they are current.
The same graph, the same confidence, available to anything that can make an HTTP call. Subscribe to changes. Trigger your own systems on confirmed edges. Wire your CI to fail PRs that touch a high-confidence boundary.
import { blastmap } from "@blastmap/sdk";
// Walk the model from a changed node, ranked by confidence.
const radius = await blastmap.graph.blast_radius({
source: "repo:acme/billing@a8f3c21",
maxHops: 3,
minConfidence: 0.2,
});
for (const hit of radius.nodes) {
console.log(hit.id, hit.confidence, hit.provenance);
// > "repo:acme/checkout" 0.94 [openapi, observed-rpc]
}curl https://graph.acme.dev/v1/blast-radius \
-H "Authorization: Bearer $BLASTMAP_TOKEN" \
-d '{
"source": "repo:acme/billing@a8f3c21",
"max_hops": 3,
"min_confidence": 0.2
}'
# returns {"nodes": [...], "freshness": "14s", "verified_at": ...}Webhook on every confirmed edge change. Trigger your own pipelines without polling.
Fail PRs that touch a high-confidence integration without a migration plan. The model knows the consumers.
Pipe the graph into your dashboard, your runbook engine, your internal portal. Same data, your shape.
The OSS code graph is the wedge. Wiring runtime turns it into a live twin. Agents act on the twin. Each layer earns the next.
The OSS code graph. Every cross-service edge across every repo and org, including the invisible ones formal-schema tools miss.
Runtime signals fold in. k8s state, traces, eBPF, logs, cost, the bus. Observed reality sits next to declared intent. Edges confirmed or downgraded against ground truth.
Agents become buildable on the model. Each does one operational job end to end, cites evidence, refuses to guess when the evidence is not there.
Blast radius is one query over the model. The query that started everything.
Health, changes, deploys, traffic, cost. The same substrate, refracted into the lens you happen to need. Every chart you usually rebuild from scratch.
Anyone on the team can answer what depends on this, what calls billing, what would break, without paging the senior architect. The architect stops being the bottleneck and starts being the architect.
Ramps up on the system on day one, without booking time with three different seniors.
Sees what changed in the window and the most likely cause with cited evidence. Stops the archaeology.
Reads who owns what and where the bus factor is. Without asking the team to fill out another spreadsheet.
Finds every consumer of the API they want to bump. Bounds the blast. Plans the deprecation, does not guess at it.
Stops being the bottleneck. Stops being the answer to every 'what depends on this'. The team finds out for themselves.
Reads cost over the graph, not over a billing CSV. Knows which module rents the GPU pool nobody calls.
The shared thread: provenance and confidence are the discipline that makes the labor safe to sell. An agent that is confidently wrong is worse than none.
Resolve · Traversal · Cleric · Causely
Runtime-only, reconstruct context per incident, so they guess. blastmap agents run on a durable code-plus-runtime model, so they compound and they cite.
Cortex · Port · Backstage
You maintain it by hand. blastmap tells you what happens if you touch it, then does something about it. Automatic, verified, and it acts.
Both categories default to SaaS. They ingest your topology into their cloud and read it from there. blastmap runs in your network. We never see your graph.
Five agents that fall directly out of the model. Each does one operational job, cites its evidence, and refuses to guess when the evidence is not there.
Walks the live model from the changed node and writes the confidence-ranked comment a senior reviewer would have written. The PR knows what it might break before merge.
Page lands and the same brain runs the recon: window, traces, recent deploys, the most likely cause with cited evidence. The on-call reads a verdict, not a smoking pile of logs.
Catches the breaking schema change the moment it lands, walks every consumer from the model, blocks the merge if anyone is on incompatible shape, proposes the shim.
Sweeps runtime usage against the graph. Names the modules paying for capacity nobody calls, and proposes a new shape the model can verify is safe to apply.
Watches declared shape against observed reality. Flags the moment k8s drifts from the manifest, names the divergence, routes to the team the model says owns the node.
Get the v0.1 launch notification and a 30-day head start before public release.