Gnosis AI (Air)

See what your coding agents did, what it cost, and why. Then make them better.

Air turns the Claude Code, Codex, Cursor and Copilot sessions in your workspace into a living knowledge base, reviews every change an agent makes, keeps AI spend in view, and hosts the agents in a chat that already knows the project's history. Everything runs on your machine.

Cost awareness and optimization

The AI spend chip in the status bar and the AI Spend Report it opens.

Spend where you decide. A status-bar chip with Day / Week / Month totals, a cost badge on every conversation and task, and an AI Spend Report: cost per day, per activity, per feature, and the costliest tasks.
See what eats your context window. The Context tab shows the latest call against the limit, its composition, and the past messages that add the most to every later turn.
Automatic Context Optimization (preview, on by default). The hidden reasoning of unrelated earlier tasks is dropped from what the agent re-sends each turn. Transcripts on disk are never rewritten. The composer toggle shows the savings (Optimize · −38k tokens).
Every provider priced. Cursor and Copilot sessions carry no usage data, so gnosis prices them from the agents' own records.
Cheap models for cheap work. Default models per kind of work: new chats, Assistant Mode, DevOps macros.
Quality beside cost. Every task carries an effectiveness score and concrete suggestions with an Apply button.

What the model receives on the next turn. Only the thinking of unrelated tasks is dropped.

The composer toggle in its four states: off, armed, working, on.

Code and worktree reviews

Reviews read the diff together with the conversation that produced it, so they can tell an intended change from an accident.

Worktree isolation by default. Every coding task runs in its own git worktree, named after the task. A per-chat picker offers Worktree isolation, Current branch or Agent decides. Cursor's own worktrees are adopted automatically.
Automatic Code Review (preview, on by default). After every agent turn that changed code, only the files the turn touched are re-analyzed. Critical findings land in the chat's Findings tab with Handle, which hands the finding back to the agent as a prompt.
The worktree page. One worktree set across every repository of the workspace, in five tabs: Summary (Why / What / How per change, affected flows, risk), GitOps (pull, commit, push, PR, checks, with Fix with agent), Changes, Knowledge and Findings.
Branch review on demand. A living HTML report: goal, component map, reading order, adjudicated findings behind a multi-layer false-positive defense, affected flows, reusability scan and a review-priority ranking.
Code Review Map and Code Tour. The component diagram with drill-down, and a guided editor tour through the recommended review areas.
Your own review rules. Scaffold .gnosis/review-rules.md, or let Air suggest rules from the comments reviewers keep repeating on your PRs.

The new-chat page: the workspace default is pre-selected; the first message locks the choice.

Air registers a Cursor worktree when it is created and tells the agent inside it where it is.

The worktree page: one set across two repositories, and a change group stated as Why / What / How.

A chat with its side panel on the Findings tab after an automatic review.

One turn, from edit to findings. Runs never overlap: a second turn queues a single rerun.

Knowledge extraction and agent tools

Every session is ingested the moment it changes and distilled into a persistent record: decisions, specifications, observations and goals, each linked to the code it touched. None of that is in the code or the git log. Now your agents can read it.

A knowledge graph for agents. The read-only gnosis knowledge CLI links tasks, code and decisions: "knowledge blame" for any line, semantic search over past decisions and over the codebase, and everything the other agents on your worktree already decided. Every answer links to the next command.
Agents that look before they edit. Instrumentation writes the prompt, skills and subagent that make a knowledge lookup step 1 of every task, for Claude Code, Cursor, Copilot and Codex. Project scope never modifies a file git tracks.
Related context, injected. When a task belongs to a scope with prior work, the agent's next prompt says so and how to load it. The Related tab lists the sibling tasks.
Semantic code search over the main checkout and every active worktree, for you (Ctrl+Alt+S) and for the agents.
Flows and AI Blame. Call-graph navigation with a N flows CodeLens, and git blame for your AI tools: which agent and conversation last touched a line.

The files written at each instrumentation scope. Green entries are Air's; nothing else is touched.

Chat capabilities and integrated knowledge

The built-in chat hosts coding agents over the Agent Client Protocol: Claude Code and Codex CLI out of the box, any other ACP agent via settings.

Conversations panel. Every session of the workspace grouped by worktree set, with status (agent working / your turn / blocked on you), cost and changed files.
The side panel beside every chat: Knowledge, Related, Score, Cost, Context, Findings and Tasks.
The topic timeline. A long chat folds into the topics the session went through, each with a headline stating its outcome and what it cost. The current topic reads plainly; the history reads as what was settled, not what was said.
Task Queue (experimental). Type while the agent works. Air decides whether the message steers the current work or is the next task, and offers queued tasks when the turn ends.
Spin work off. An agent or you (/new-task) starts a new tracked chat seeded with the goal and context, nested under the originating one.
Assistant Mode (experimental). One chat leads a small team: it plans tasks, prepares worktrees, assigns each task to an agent on the model that fits, monitors them and reports once.
Structured questions, turn alerts. Multiple-choice questions and permission requests as cards. A chime or notification when an agent hands control back.

The chat folded into topics; the current topic plain.

A message sent mid-turn becomes a queued task, offered when the turn ends.

You talk only to the assistant. The assistant talks to its tasks.

The Assistant toggle, and the assistant's tasks nested in the Conversations list.

Shared knowledgebase

One team, one memory. Point gnosis at a git repository and the watch daemons keep it in sync.

Every task's record is pushed as it lands and pulled from your teammates' branches. An agent on a branch a colleague started reads their decisions before making its own.
Worktree groups travel with it. Air: Open worktree group… recreates a shared feature's worktrees on your machine and opens the worktree page over it.
Status at a glance. The status-bar chip reads Shared KB, KB Connected or KB Offline.

The status-bar chip's three states, and what flows through the shared repository.

Requirements and setup

Python 3.8+ on your PATH, used only to bootstrap; gnosis gets its own Python 3.12 environment.
A JetBrains account, signed in once by the first-run wizard. It powers semantic code search and, if you choose it, inference.
An LLM for analysis: JetBrains AI credits, Cursor, an Anthropic API key, or GitHub Copilot. Credentials live in the OS keychain, never in settings.json.
Git, for worktrees, reviews, blame and the shared knowledgebase.

First run. Approve setting the folder up. The wizard signs you in, installs the managed components in the background, asks which LLM to use and verifies it with one round trip. Ingestion of the sessions already on disk starts right away. The Status panel hosts install, update and re-index actions. Gnosis: Remove gnosis components returns to the first-run state.

Settings

All settings live under air.*, each with an illustrated guide in the Conversations panel's Settings tab. The ones you are most likely to touch:

Setting	Default	What it does
`air.autoReview.enabled`	`true`	Automatic review after each code-changing turn.
`air.optimizeContext`	`true`	Default for the per-chat context-optimization toggle.
`air.worktrees.defaultScope`	worktree isolation	Isolation scope for new tasks.
`air.installScope`	`workspace`	Where the agent wiring is installed (`workspace` or `user`).
`air.taskQueue.enabled`	`false`	Queue next tasks typed mid-turn.
`air.assistantMode.enabled`	`false`	Show the Assistant toggle.
`air.chatDefaultModel` / `chatDefaultMode`	Opus / `accept-edits`	What new chats start on.
`air.acpAgents` / `defaultAcpAgent`	Claude Code, Codex	ACP agent definitions and the default.
`air.turnAlert.mode`	`off`	`sound`, `notification` or `both` when a turn ends.
`air.jbcontext.enabled` / `air.callGraph.enabled`	`true`	Semantic code search and call-graph integration.

Privacy

Credentials stay in your home directory, in the OS keychain when available.
Analysis runs on transcripts and repositories already on your machine. Network calls go only to the LLM provider you chose, to JetBrains for sign-in and code search, and to your shared knowledgebase repository if you configure one.
Anonymous usage counters are gated by VS Code's telemetry level and never carry prompts, contents or paths.

Development

npm install
npm run compile     # extension (out/) + webviews (media/)
npm run test:unit   # fast unit tests
npm test            # integration tests (run outside VS Code's terminal)
npm run package     # produce a .vsix

Press F5 for an Extension Development Host. Architecture and test layers: CLAUDE.md; feature docs: docs/.

Gnosis AI

Roni Dover