Source-code facts,
not source-code vibes
Bo turns a source repository into a queryable semantic graph — symbols, contracts, dependencies, complexity, responsibility, refactor pressure. Built deterministically by analyzers, not inferred from prose by a model. The substrate every coding agent should plan against.
Deterministic analysis first. LLMs should not be the parser.
Modern coding agents are powerful, but they still lose time rediscovering code structure from raw text. Bo gives them a deterministic map before they start planning: what symbols exist, where they live, how they relate, what carries unusual complexity, what crosses architectural boundaries, what refactor pivots are worth investigating first.
Bo doesn't ask a model to parse code, count complexity, or infer dependency edges from prose. Those are jobs for repeatable analyzers. Models can then use the resulting graph to plan, explain, and generate code with context — instead of guessing it back from the surface text on every turn.
What Bo produces
Repo,Module,Filerecords — the structural skeletonSymbolrecords for classes, interfaces, functions, methods, records, structs, and enumsContractrecords for signatures, inputs, outputs, async behavior, nullability, and errors- Dependency edges at both file and symbol granularity
- Boundary interaction records for database, network, filesystem, auth, logging, cache, and queue behaviors
- Effect, complexity, and responsibility profiles
- Refactor pressure scores and pivot recommendations
All of it streams out as a stable JSON contract. Useful directly. Much more useful when it lands in BogDB as a queryable code-intelligence graph.
Try it in two minutes
# Inside a checkout
bo init
bo index --json --full > codegraph.json
# Probe a specific file
bo pivot src/ExampleService.cs --json
# Once BogDB persistence is wired in
bo index --store bogdb --db .bo/codegraph.bogdbLocal-first by default — the CLI works on any checkout without a hosted service. Apache 2.0, no credentials in output, no hidden network calls.
Design principles
- Deterministic analysis first. LLMs are not the parser.
- Structured output by default. If an agent needs it, it should be machine-readable.
- Local-first operation. The CLI runs on a checkout without a hosted service.
- Graph-native shape. The data model maps cleanly into BogDB nodes and relationships — no impedance mismatch.
- Boring security posture. No credentials in output, no surprise network calls during local indexing.
- Clear extension seams. Enterprise search, hosted orchestration, and governed workflows layer on top — without bloating the open CLI.
Where Bo fits in the Beyond Ordinary stack
Bo is the planning provider behind the Planning boundary in ASE. When ASE needs work decompositions, validation plans, code intelligence, or handoff artifacts, it asks Bo. Bo produces structured ACOP-compatible records and hands them into CLAiR through the /bo/intake endpoint, where they become actionable work items.
On the storage side, Bo's JSON contract is the primary input shape for BogDB's codegen MCP server. bo index --json --full emits exactly the records BogDB expects, so the graph in your database is the same shape your CLI just produced — no schema translation, no lossy conversion.
Bo is replaceable. ASE talks to the Planning boundary, not to Bo specifically. Bring your own planner if you have a better one; ASE and CLAiR don't care, as long as it implements the contract.
Why coding agents need this layer
Watch an agent work without code intelligence and you'll see it spend tokens reconstructing structure: re-reading files to remember where a class lives, re-tracing dependency edges, re-deriving complexity from a paragraph it just produced. Every one of those operations is a deterministic analyzer's job. Every one of them, asked of a model, costs latency and reduces the budget left for actual reasoning.
Bo runs once, produces the map, persists it in BogDB. After that, agents query for the answer instead of rederiving it. The result: faster turns, smaller token bills, fewer hallucinated dependencies, and a consistent shared model of the codebase that humans and agents can both rely on.
Give the agents a map before they start planning
Bo is open source under Apache 2.0 and lives at github.com/BeyondOrdinary/bo-cli. Clone it, run bo index --json --full in any .NET repo you maintain, and see what the deterministic map of your own code looks like.