AIRE – AI Reliability & Resilience Engine

AIRE is a command-line tool that gives an AI coding agent a grounded, current picture of your codebase — and then checks what the agent gives back.

It runs entirely on your machine. It does not upload your source code.

npm install --global aire-suite
cd /path/to/your/project
aire

Contents

• What AIRE does
• Requirements
• Installation
• First run
• The interactive interface
• Project mapping
• Context and freshness
• Verification
• The daemon
• The MCP server
• Claude integration
• Antigravity integration
• Codex and other AGENTS.md agents
• Other MCP clients
• Ponytail
• Security and privacy
• Updating
• Troubleshooting
• License
• Support

What AIRE does

An AI coding agent fails in two directions. It does not know enough about your project, so it invents an API that does not exist; and you cannot easily tell that it did. AIRE addresses both ends:

• Maps your project into a structured graph of files, symbols, imports, and dependencies — the ground truth.
• Prepares context: given a task, selects the files and rules that are actually relevant, within a token budget, instead of dumping the repository at the model.
• Verifies an AI-proposed change against the real project graph, reporting every symbol, import, and package it references that does not exist.
• Scans for secrets and risky patterns.
• Serves all of the above to your AI client over MCP, so the agent can call it directly.

Requirements

• Node.js 20 or newer. Check with node --version.
• Platforms: macOS, Linux, and Windows.

AIRE installs three native tree-sitter packages, which npm compiles or fetches a prebuilt binary for during installation. On a machine with no prebuilt binary available, this needs a working C/C++ toolchain.

Deep source analysis is strongest for JavaScript and TypeScript, which have full tree-sitter grammars. Other languages are mapped at the file, dependency, and structure level.

Installation

npm install --global aire-suite

This installs one executable, aire:

aire --version

The npm package is public. The AIRE source repository is private, and the package is proprietary — see License. Everything published inside the package is, of course, downloadable and readable by anyone who installs it.

First run

From the root of a project:

cd /path/to/your/project
aire

With no arguments, aire opens its interactive home screen. Nothing has been written to your project yet.

To set the project up:

aire setup --quick

--quick runs the short path: initialize, map, prepare context, and then offer to configure your AI client and start the daemon. It asks before it writes anything outside the project, and before it starts a background process.

For the full wizard, which walks through each client it finds:

aire setup

Nothing about installation configures your editor. npm install runs no postinstall script and touches no external tool. AIRE only changes an AI client's configuration when you run aire setup, aire bootstrap, or aire integrations, and only after you consent.

To see what setup would do, without doing it:

aire bootstrap --dry-run
aire integrations detect

The interactive interface

Running aire with no arguments opens a terminal home screen: project status, what is stale, and the actions available, navigable with the arrow keys.

It is interactive only when it is talking to a terminal. In a pipe, in CI, or with NO_COLOR, CI, or TERM=dumb set, aire never opens the navigator and never prompts — it prints and exits. Every command that can change something also accepts --non-interactive and --yes.

Project mapping

aire map

Builds the project map — files, symbols, imports, exports, and dependency edges — and writes it under .ai/. This is the ground truth everything else reads.

Context and freshness

aire context "add rate limiting to the upload endpoint"

Selects the files and rules relevant to that task, inside a token budget, and prints them. Useful flags:

• --focus <file...> — the files you are working in; the strongest relevance signal.
• --explain — what was selected, what was dropped, and why.
• --max-tokens <n> — override the configured budget.
• --session <id> — continue a conversation: return only what changed since this session last asked.

To regenerate the durable context file (.ai/context.md) from the current map:

aire context --update

Freshness. The map and the context are derived from your source, so they go out of date the moment you edit a file. Re-running aire map && aire context --update regenerates them. To keep them current automatically, run the daemon.

To see what the engine currently thinks:

aire status

Verification

aire verify                      # verify changed files
aire verify src/server.ts        # verify specific files
aire verify --response reply.md  # verify an AI's proposed change ('-' reads stdin)

Checks every symbol, import, and package the code references against the real project graph, and reports what does not exist. It exits non-zero on failure, so it works in a pre-commit hook or in CI.

Related:

aire security          # scan for secrets and risky patterns
aire benchmark         # measure the engine on this project
aire tokens            # what context has cost you

The daemon

The daemon watches the project and keeps the map current in the background.

aire daemon start --background
aire daemon status
aire daemon logs
aire daemon stop

It is local: a file watcher plus a loopback HTTP API. It is never started by npm install, and never starts itself — you start it, and aire daemon stop stops it.

The MCP server

AIRE speaks the Model Context Protocol, so an AI client can call it as a tool instead of you pasting output into a chat.

aire mcp start     # serve over stdio (what a client runs)
aire mcp status
aire mcp doctor    # diagnose a broken client integration

aire mcp doctor is the first thing to run when a client cannot see AIRE.

You rarely run aire mcp start by hand — the client runs it, using the configuration that aire setup writes.

Claude integration

aire setup detects Claude Code and Claude Desktop and, with your consent, registers AIRE as an MCP server.

aire integrations detect            # what is installed on this machine
aire integrations add claude-code   # register AIRE with Claude Code
aire integrations status            # is it actually wired up
aire integrations doctor            # why is it not working

For Claude Code you can choose the scope:

• --scope project — writes .mcp.json in the project; shared with your team.
• --scope user — writes your user configuration; applies to all your projects.

aire bootstrap additionally writes a managed section into CLAUDE.md, so the agent knows AIRE is available and when to call it. Managed sections are fenced with markers, and AIRE only ever rewrites its own section — your prose is left alone.

Antigravity integration

aire setup detects Antigravity and registers AIRE as an MCP server, and aire bootstrap writes its managed guidance section, on the same consent rules as Claude.

Codex and other AGENTS.md agents

AIRE has no Codex-specific integration, and does not detect or configure Codex.

What it does do is write a standard AGENTS.md (via aire bootstrap) — the convention that OpenAI Codex and a number of other agents read for project instructions. If your agent reads AGENTS.md, it will pick up AIRE's guidance section. That is the whole of the support, and it is worth being precise about it: there is no MCP auto-registration for Codex.

Other MCP clients

aire integrations knows about Cursor, Windsurf, Cline, Roo Code, and Continue, and can write a generic MCP configuration for any other client that speaks MCP over stdio:

aire integrations list
aire integrations config --show     # print the canonical configuration
aire integrations add generic-mcp

Support means "AIRE can write the MCP configuration this client expects, and aire integrations doctor can check it." It does not imply any endorsement by, or testing against every version of, those products.

Ponytail

This release does not bundle, vendor, or redistribute any Ponytail code, rules, templates, skills, hooks, or runtime assets. There is nothing to attribute and nothing to configure.

Security and privacy

Your source code stays on your machine. AIRE does not upload your source, your project map, or your context to the author or to any third party. There is no account, no API key, and no phone-home.

The only network requests AIRE makes on its own are to the npm registry, and only to answer "is there a newer version of AIRE?" — that is aire update and aire update check. Nothing about your project is sent in that request. If you never run them, AIRE makes no network requests at all.

If you configure AIRE as an MCP server, your AI client will send AIRE task descriptions and receive project context back. That traffic is between the client and the local aire process on your machine. What your AI client then does with that context is governed by that client's privacy policy, not by AIRE.

What AIRE writes. Everything lives inside your project:

| Path | What it is | | --- | --- | | .ai/ | project map, context.md, rules, learnings | | .ai/telemetry/token-events.jsonl | local token-usage log, append-only | | .aire-cache/ | derived, disposable state | | aire.config.json | your configuration |

Telemetry is local. .ai/telemetry/token-events.jsonl is a plain JSONL file of token counts, written on your disk and never transmitted. Read it, or delete it:

aire tokens                      # what it says
rm -rf .ai/telemetry             # delete it
aire context --no-telemetry ...  # do not record this one

Secret scanning. aire security looks for credential patterns in your code. It reports findings locally; it does not transmit them. Optional external scanners, if you have them installed, stay optional.

Consent. AIRE modifies a file outside your project only when you run a command that says it will, and only after you approve. npm install runs no postinstall script, configures no editor, and starts no daemon.

Updating

aire update          # check, then install if there is a newer version
aire update check    # report only, never installs

Or by hand:

npm install --global aire-suite@latest

aire update check --format json is machine-readable. Both check and status exit 0 when the registry is unreachable — being offline is not an error — and report latest: unknown with the reason.

Troubleshooting

aire: command not found after installing. npm's global bin directory is not on your PATH. Find it with npm bin -g and add it.

Installation fails compiling tree-sitter. No prebuilt binary matched your platform and npm fell back to building from source. Install a C/C++ toolchain (Xcode Command Line Tools on macOS, build-essential on Debian/Ubuntu, the Visual Studio Build Tools on Windows) and reinstall.

My AI client cannot see AIRE.

aire mcp doctor
aire integrations doctor

Between them these check that the client's configuration exists, that it points at an aire executable that really is there, and that the server answers. They print the fix, not just the failure. Most often, the client needs restarting after its configuration changed.

A command hangs. No AIRE command should need a TTY. Add --non-interactive, or set CI=1. If a daemon is wedged, aire daemon stop.

Everything is confusing.

aire doctor

One health pass over the engine, the modules, and the MCP integration.

License

Proprietary. Copyright © 2026 Darshan Vithani. All rights reserved.

You may install and run AIRE, including commercially. You may not redistribute, resell, or offer it as a service. See LICENSE for the full terms and THIRD_PARTY_NOTICES.md for the open-source components AIRE bundles, each under its own license.

The AIRE source repository is private. This npm package is public: it contains a compiled bundle, which anyone who installs it can read.

Support

AIRE is published as-is, with no support obligation — see sections 7 and 8 of the LICENSE.

Before reporting anything, run aire doctor and include its output; it answers most questions on its own.

The source repository is private, so it is not a place you can file an issue. Support, where it is offered, is at the author's discretion.