AIR. Explore the prototype
Semantic infrastructure for coding agents

Give coding agents a semantic understanding of your codebase.

Less searching. Less rereading. More understanding.
AIR is building the semantic layer that connects your agents to the structure behind your code.

See how AIR works Follow the roadmap

Your agents. Your languages. No application rewrite.

REPOSITORY INTELLIGENCEConcept preview
The context this task needs.

A symbol, its dependencies, its contract and its tests.

FOCUSED
Structure over repeated search01 / AIR CONTEXT ENGINE

Keep what you’ve built

Your codebase stays yours.

TypeScriptJavaScriptPHPPythonJavaRustC#+ more

Existing-language adapters are on the roadmap. No migration to AIR required.

A better starting point for every task

Code is connected.
Your agents should know how.

Give agents the relationships behind the files, so they can spend less effort reconstructing what your team already built.

01 / FOCUS

Less context.
More signal.

Retrieve the symbols, callers and tests relevant to a task instead of repeatedly loading entire files.

Designed for lower context overhead
02 / UNDERSTAND

See the change.
And its impact.

Make dependencies, types, effects and constraints explicit before an agent proposes a change.

Designed for better dependency awareness
03 / VALIDATE

Smaller changes.
Clearer evidence.

Check semantic patches against revisions and declared requirements, then produce a normal source diff.

Designed for fewer repair cycles

These are product goals. Repository-level savings and change quality will be measured in pilots, not assumed.

The layer between intention and implementation

Better agents.
Not different agents.

AIR is designed to make the coding tools you already use more effective. Model-independent infrastructure, built around your repository.

YOUR CODING AGENTS
⌘Codex
✳Claude Code
◈Copilot
✧Gemini
↳Custom Agent
THE SEMANTIC LAYER

AIR Engine

Understand → Focus → Validate

TypesDependenciesConstraints
YOUR EXISTING CODEBASE

Your repository

Same languages.
Same source of truth.

Integration vision · Agent and repository adapters are planned, not available today.

TASK-SPECIFIC CONTEXT

The right part of the graph.
Not another pile of files.

Start with a bounded view of relevant symbols, dependencies, callers and tests. Expand only when the task needs more information.

Relevant symbolsConnected dependenciesSource references
Illustration of the planned repository workflow

Built in the open. Grounded in evidence.

A clear direction.
An honest starting point.

The engine prototype is working. The next step is proving useful context on an existing repository, with measurable outcomes.

WORKING PROTOTYPE00

The semantic foundation

Binary graphs, typed construction, checked edits and demonstrated native and static-web outputs.

Explore what exists
NEXT MILESTONE01

Repository context pilot

One source language. One agent integration. Relevant symbols and dependencies, measured against the existing workflow.

Read-only first · No application rewrite
THEN02

Controlled source changes

Semantic patches that produce small source diffs and pass the repository’s language, build and task checks.

Preconditions · Validation · Review

For the technically curious

Try the foundation.
Help shape what comes next.

The current local prototype demonstrates semantic graph construction and checked outputs. Repository indexing and agent adapters are the next product milestone.

Read the product strategy Information for agents
LOCAL PROTOTYPE 
cd ~/air
python3 -m examples.session_demo
./build/session-hello
Hello world!

Run in an existing AIR checkout. Python 3.10+ and Clang or GCC required.

The future of agent-assisted engineering

Your codebase.
Understood.

Better context. Explicit relationships. Changes you can check.

Explore the AIR vision