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, licence and releases. It is free for individuals, education and organizations below the licence thresholds.

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": ["DemoCompositionRoot"] }
}

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. Explicitly named seed symbols stay in the package; AICB first reduces method detail and then removes less-relevant surrounding content when the budget is tight. It does not cut text in the middle of a block, and a leading note discloses types, tests or siblings that were omitted. AICB can therefore tell you that a bundle was structurally reduced or capped; it cannot certify that the remaining budget is sufficient to solve the task correctly. Whole-document rendering can use the same budget pipeline through a pipeline profile, including a configurable overshoot allowance and an optional trimming report.

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 <ai> 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.

How analysis and memory work

.sln / .slnx / .slnf + C# + XAML/AXAML
                 ↓
        MSBuild + Roslyn semantic models
                 ↓
  AICB facts and consolidated semantic indexes
                 ↓
 individual answers or budgeted AI-Builder-MD

AICB is more than a response cache around Roslyn. During analysis it walks the solution's C# documents, records declarations, calls, type references and other facts, then consolidates caller and type fan-in, implementations, resolved markup references and transitive side-effect classifications. Tools traverse or project that warm model for a particular question; context tools select and render a task-specific slice. This does not mean that every possible answer or runtime relationship is precomputed.

An MCP session belongs to one aicb mcp process and pins both the analyzed graph and its Roslyn workspace. A second server process builds its own session. The desktop app, CLI and MCP server use the same analysis and rendering engine and can share configuration and persisted snapshots through the local database, but they do not share one live in-memory graph. Within one session, only one refresh runs at a time; concurrent callers join it. A source-only edit can take the incremental path, replaying changed document text without reloading the workspace. When that path is unavailable, or when force: true is requested, AICB fully reloads it.

Live sessions, snapshots and persistent codebase memory

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

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# and selected XAML/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; runtime-produced registrations are disclosed as dynamic or unknown rather than invented.
• XAML binding analysis resolves paths only where the source and data type are safe to establish. Unknown scopes are skipped conservatively.
• A reported side effect is a conservative static contact classification propagated through known call edges. It is not general data-flow, taint or runtime state analysis.
• 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: