Why Apogee¶

The problem¶

AI coding assistants are powerful but undisciplined. They don’t follow your team’s workflow, don’t understand your codebase’s architecture, and can’t coordinate multi-step work across features. Every session starts from scratch. The results are impressive individually but inconsistent at scale — no governance, no memory, no structure.

Teams adopting AI assistants face a choice: let the AI work freestyle and accept the inconsistency, or spend more time supervising the AI than doing the work yourself. Neither is acceptable.

What Apogee does¶

Apogee adds structure, analysis, and governance to AI-assisted development. It sits between you and your AI coding assistant and provides:

Structured lifecycle skills — 102 reusable workflows for design, planning, implementation, testing, review, and release. The AI follows consistent multi-step processes instead of ad-hoc prompting. Skills compose into chains with checkpoint and resume across sessions.
Code Property Graph engine — static structural analysis across 8 languages. Call graphs, impact analysis, security scanning, backport checking, branch divergence — at kernel scale (68M nodes, two branches indexed in 30 minutes). Your AI assistant understands your codebase’s architecture, not just the file it’s looking at.
Governance gates — policy-driven approval gates at lifecycle boundaries. Constraint routing classifies every message as read or write intent. Maturity-aware documentation prevents writing docs for features that haven’t shipped. Proof harness for release verification.
Layered skill inheritance — framework, organization, team, repository, and user layers. Override any skill at any level without forking. Teams get consistent workflows; individuals get customization.

Who Apogee is for¶

Apogee serves three audiences, each using different parts of the framework:

Engineers using AI assistants — the broadest audience. If you use Claude Code, Cursor, or any MCP-compatible host, Apogee gives your assistant structured workflows, constraint routing, and governance gates. pip install, bootstrap your repo, and your AI assistant immediately works within your team’s process instead of freelancing.

Platform and DevOps teams — teams building automated code review pipelines, CI quality gates, and multi-repo governance. Apogee’s CPG engine runs headless: index a branch, run security scan, compare against baseline, flag regressions. Incremental indexing costs seconds. The skill library provides the review structure; the MCP server provides the integration point.

Kernel and systems engineers — engineers working on large, complex codebases where naive AI assistance breaks down. The CPG engine handles kernel-scale analysis. Cross-branch comparison catches backport risks. Security scanning traces data flow across subsystems. The large-systems- change workflow provides 7-phase structured patch development from problem scoping through upstream submission.

How Apogee differs¶

vs. GitHub Copilot Workspace / Copilot Chat: Copilot suggests code inline and can make edits across files, but has no lifecycle structure. There are no governance gates, no constraint routing, no multi-step chains with checkpoint/resume, and no cross-branch analysis. Copilot operates at the edit level; Apogee operates at the workflow level — design, plan, implement, review, release. The two are complementary: Copilot handles line-level completion, Apogee handles the process around it.

vs. Cursor Rules / Claude Code CLAUDE.md: Project rules and system prompts are suggestions that the AI can ignore or misinterpret. Apogee’s constraint routing enforces read/write boundaries — the AI cannot invoke write-mode skills while in read mode. Immutable gates cannot be overridden by policy exceptions. Skills are compiled into versioned Python modules with deterministic registries, not loose Markdown that drifts as the project evolves.

vs. Sourcegraph Cody: Cody provides codebase-aware chat and context retrieval. Apogee’s CPG engine goes deeper — call graphs, data flow tracing, security scanning, backport safety checks, and cross-branch divergence analysis, all queryable via 13 MCP tools. Cody answers questions about code; Apogee analyzes code structure to inform workflow decisions (e.g., “is this function safe to backport?” is a structural query, not a search result).

vs. CodeQL / Semgrep: These are query-only tools — they find issues but don’t structure what happens next. Apogee combines analysis with workflows and governance: find the bug, structure the fix workflow, gate the review, verify the release. The CPG engine is one component, not the whole product.

vs. trunk.io / CI/CD platforms: Apogee doesn’t replace your CI — it structures what the AI does before code reaches CI. Governance gates work at the development lifecycle level (design, plan, implement, review), not at the merge/deploy level. Apogee’s CI integration produces structured reports and verification artifacts that feed into your existing pipeline.

What ships today vs what’s planned¶

Component	Status	What it does
Skill library (102 skills)	Shipping	Design, plan, implement, test, review, release workflows
MCP server (27 tools, 8 resources)	Shipping	IDE integration for Claude Code, Cursor, OpenCode
CPG engine (8 languages)	Shipping	Static analysis, call graphs, security scanning, backport checking
Manifest scoring	Shipping	Codebase snapshots with quality scores and AI regrading
Constraint routing	Shipping	Read/write intent classification and enforcement
Governance gates	Shipping	Policy-driven approval at lifecycle boundaries
Chain engine (8 chain types)	Shipping	Multi-step execution with checkpoint/resume
Perigee (Elixir/OTP executor)	Shipping	BEAM-native chain execution with OTP supervision and crash recovery
Unix socket transport	Shipping	Dual-channel socket connection to Perigee
Multi-agent coordination	Shipping	Project-scoped sessions, agent identity, session transfer, EventBus
Multi-model pipeline engine	Designed	Autonomous pipelines with OpenHands, opencode, and Continue CLI backends
Multi-repo git orchestration	Designed	Structured git coordination for pipeline steps
Content-addressed artifact store	Designed	LanceDB-backed artifact management replacing flat files

Shipping means tested, documented, MCP-registered, and used in production workflows. Built means code exists and tests pass but the component is not yet user-facing. Designed means a design document exists with architecture and implementation tiers but no code has been written. See STATUS.md for the complete classification.

Getting started¶

pip install apogee          # or: just install
apogee-repo bootstrap .    # bootstrap your repo

See Quickstart for the full guide.