AIContextBuilder

AIContextBuilder (aicb)

Give coding agents a Roslyn-accurate map of your C#/.NET solution. aicb is a code intelligence server for C# and .NET: it answers questions about callers, implementations, dependency injection, tests, side effects and change impact, then packs the relevant code into compact Markdown for an LLM. It runs locally as an MCP server and CLI; a Windows desktop app adds visual context selection, analysis and editing.

The software is closed source. This public repository contains its

documentation, license and releases. It is free for individuals, education and

organizations below the license thresholds.

This page is a short tour, not the reference. It names 38 of the 54 tools an agent sees by default; the three manuals run to 35 chapters, about 37 times the length of this page.

See it answer a code question

Ask your coding agent:

What could be affected if I change ColorMixerService? Use AICB.

Or call the same tool from a terminal:

aicb call impact_of_change --sln C:/repo/App.sln --arg symbol=ColorMixerService

Abridged output from the bundled ColorMixer.SelectionLab sample:

{

"symbol": "ColorMixerService", "resolvedKind": "type", "directCount": 1, "transitiveCount": 2, "risk": "low", "productionImpactCount": 2, "directImpact": { "items": [ { "name": "DemoCompositionRoot", "file": "ColorMixer.SelectionLab.ConsoleApp/DemoCompositionRoot.cs", "line": 9 } ] } }

The desktop app's MCP Usage page records calls locally and separates guided refusals from suspected defects:

That answer comes from the Roslyn symbol graph, not a substring search. AICB distinguishes overloads, follows interface and override relationships, understands partial types and records DI construction paths.

Build context that fits the task

AICB does more than answer individual symbol questions. It can assemble a focused, task-specific context package for an agent instead of sending an unfiltered source dump:

The focused context tools accept a token budget, so a package fits the room your agent has. The symbols you name stay in; when the budget is tight, the package becomes less detailed around them instead of being cut off in the middle of a block, and a leading note says which types, tests or siblings were left out. AICB can therefore tell you that a bundle was reduced or capped; it cannot certify that what remains is enough to solve the task correctly. Whole-document rendering can use the same budget through a pipeline profile, with an allowance for overshoot and an optional report of what was trimmed.

The result is AI-Builder-MD: structured Markdown for an LLM, containing the selected code together with symbol relationships, architecture graphs, semantic metadata and provenance. It can use the established tag notation or YAML. See the context-document guide and the task-packing tools.

Add explicit meaning with AI Tags and semantic annotations

AICB works without annotations. Where source structure and conventions are not enough, optional tags in XML documentation let a developer state the intended role of a type or method explicitly:

/// <ai

/// role="service" /// layer="Application" /// responsibility="Coordinates order validation and submission." /// stability="Stable" /// /> public sealed class OrderService

Annotations can describe semantics such as role, domain, architectural layer, priority, stability, responsibility and side effects. Explicit values take precedence over heuristic inference; sentinel values such as none can deliberately suppress inference for one field. AICB preserves provenance so an agent can distinguish source-derived facts, author-provided meaning and inferred hints. The AI annotation reference documents the supported forms and fields.

What happens after your first question

1. The first question about a solution takes the longest. You name a .sln, .slnx or .slnf; AICB loads it the way your build would and reads its C# code and its XAML/AXAML markup.
2. The questions after it are quick. Callers, implementations, tests, injection and impact come from what the first analysis learned, as a single answer or as a context document sized to your budget.
3. Your saved edits are picked up. With the shipped settings the next question brings the analysis up to date with the saved files; an explicit refresh does the same in every setting.

AICB analyzes the solution once and then answers each question from what it learned: who calls what, which types use or implement which, what the markup refers to and which code reaches outside the program. Follow-up questions therefore come back quickly, and the context tools pick and render the part of the code a task needs. This does not mean that every possible answer or runtime relationship is known in advance.

Every agent session that starts aicb mcp gets its own analysis, and the desktop app, the CLI and the server answer alike and can share configuration and saved snapshots. After you edit source files, the next refresh picks up what changed, usually without loading the solution again (force: true loads it completely). A client that gives up waiting for a long first analysis can simply ask again: the analysis finishes anyway, and a retry with the same arguments gets it from the cache.

Live sessions, snapshots and persistent codebase memory

These states serve different purposes and should not be treated as interchangeable:

remember_codebase, recall_codebase and refresh_remembered are opt-in tools: no MCP profile exposes them, so start the server with AICB_MCP_TOOLS naming them (or AICB_MCP_TOOLS=all). recall_codebase reports whether the persisted model still matches the source, payload schema and analyzer identity. It deliberately returns the recalled model even when it is stale, with metadata that tells the agent when a live re-analysis is necessary. See sessions, recall and staleness.

What the model can and cannot prove

• AICB analyzes statically visible C# (including the C# the Razor generator compiles from .cshtml views) and selected Razor, XAML and AXAML relationships. Code reached only through reflection, runtime assembly scanning, dynamic configuration or an external consumer can remain invisible.
• DI analysis recognizes statically readable Microsoft-DI-shaped registrations and MEF export attributes; runtime-produced registrations are disclosed as dynamic or unknown rather than invented.
• A XAML binding is checked only where its data type is known for certain; where it is not, the binding is left unjudged rather than reported as broken.
• A reported side effect means the method reaches such an operation in its code, itself or through the methods it calls. It tells you that a method can write a file, not which file or when.
• Responses disclose stale sessions, unresolved projects and capped result sets. Read staleness, incompleteProjects, totalFound and truncated before treating an empty or short answer as proof.

How an agent should judge an answer

An AICB response is evidence together with its limits. Before acting on an empty, short or apparently definitive result, inspect the accompanying signals:

The MCP profile controls automatic refresh. Off only discloses drift, Reactive refreshes before a reading tool answers and i