The architecture layer for agentic development
Operate at the middle altitude
Altitude is tooling that lets developers operate at the middle altitude between writing every line of code and handing everything off to AI in natural language. Your code lives in a live map of typed scopes — and you and your coding agents read and write that map together.
curl -fsSL https://getaltitude.dev/install.sh | shmacOS and Linux. On Windows, download the binary manually.
A live capture of the board — your codebase as a map of scopes and connections — lands here before launch.
.altitude/ files — no login, no account.A codebase you can see, not just scroll
Altitude is not an editor and not an IDE. It is the tool for the architecture level — where the shape of the system lives.
Folders become typed scopes
Your codebase stops being a tree of files and becomes a catalogue of labelled units — a UI component, a state store, an API route, a migration. Each scope is a card on the board with a name, a description, and its real files behind it.
File search becomes semantic search
One search box answers both by intent (“the form that handles login”) and by name (“AuthForm”). You navigate the map by meaning, not by remembering where a file lives.
Writing code becomes arranging scopes
You and your agent define and connect the pieces; the agent fills in the implementation. The map is the plan and the record at once — every claim is committed YAML you can diff and review.
The build loop
A shared workspace for you and your agents
Both parties collaborate on the same architecture. You are not drawing a picture for an AI to build in the dark — the agent reads the map, you review its proposals, and the code and the map stay in step.
Propose
You or your agent sketch new scopes and connections on the board. Each is born in blueprint state (green — “will exist”) and listed, one row each, in the Planned changes card.
Review together
Both parties read and write the same map. Hover a row to ring the matching scope, click to fly to it, discuss, adjust. Keep what you want; discard the rest. There is no separate approve step — keeping a proposal is the decision.
Build → built
The agent implements each scope and connection and reports it built. On your open board it turns solid in place, live, with no reload — and shimmers “under construction” in its own colour while the agent works.
The board speaks git-diff
One colour grammar across every surface, so a glance tells you what is about to change.
- Green — will exist. A proposed scope or connection, not built yet.
- Red — will stop existing. Marked for removal; the agent deletes the real code, then it leaves the map.
- Amber — drifted. A built scope whose code moved underneath it, so its card may now be lying.
The map never guesses
Built-ness is only ever what the agent reported and you can see. Every state lives in committed YAML you can diff and review.
- Connections are first-class
- A link between two scopes can be real code — an API client, an adapter — with its own status. It stays proposed until the agent writes it and reports it built.
- Drift is detectable, not silent
- Each built scope stamps a fingerprint of the files it is built from. When those files move, the map flags it stale rather than letting a stale “done” stand.
- Language-agnostic
- Everything Altitude adds is plain files under
.altitude/. It works the same on a Python, Go, or Rust repo as on a JavaScript one.
Bring your own coding agent
Altitude never bundles or mandates an agent. Point whatever you use — Claude, Cursor, Codex — at Altitude over the Model Context Protocol, and it gets catalogue search, the architecture map, and the propose → build → built loop.
claude mcp add altitude -- altitude mcp --allow-ui-controlInstall Altitude
One command on macOS or Linux. Then altitude init inside any app.
curl -fsSL https://getaltitude.dev/install.sh | sh