sage

Sage

An intelligent skills framework for AI agents.

Think clearly. Work thoroughly. Deliver excellence.

Sage is a skills framework that makes AI agents think before they act, stay focused under complexity, and deliver outcomes you can trust. Built for product and engineering teams, open to any domain.

• Think first, build second — a framing round challenges assumptions before solutioning begins, preventing the most expensive mistake: solving the wrong problem
• Focus over noise — loads only what the task needs, producing sharper reasoning
• Reliable by design — 5-layer enforcement, 3 independent sub-agent reviews, quality gates with deterministic scripts
• Gets smarter over time — self-learning, memory, and ontology compound into institutional knowledge of your codebase
• Grows with its ecosystem — 38 built-in skills, extensible with 90K+ community skills from skills.sh

Why Sage

The Navigator

Most AI frameworks skip from request to implementation. Sage's navigator thinks first — mapping every request to an intent spectrum (UNDERSTAND → ENVISION → DELIVER → REFLECT) and detecting what's missing before work begins.

It starts with a framing round: surface the pain, challenge the premises, and arrive at a chosen framing — before any solutioning happens. Building without research? It tells you what 15 minutes of discovery would prevent, then lets you decide. Gap detection, not gatekeeping.

Routing is deterministic first, intelligent second: keywords match workflows before any LLM judgment. When keywords don't match, a focused sub-agent classifier picks the right phase. Every routing decision is confirmed with the user before proceeding. Smart enough to route accurately. Humble enough to ask when unsure.

The Quality Chain

AI agents drift silently — skipping steps, hallucinating imports, building the wrong thing confidently. Sage catches this at every stage:

Before implementation:

• Auto-review (sub-agent) verifies spec quality after approval — framing alignment, testable criteria, boundary completeness, edge cases, internal consistency
• Auto-review (sub-agent) verifies plan quality after approval — spec-plan alignment, task decomposition, dependency ordering, coverage gaps

During implementation:

• 7 universal coding principles loaded into the build-loop — clarity, error handling, boundary guards, minimal scope, safe APIs, consistency, behavior testing

After implementation:

• 5 quality gates sequence automatically — spec compliance, constitution compliance, code quality (independent sub-agent), hallucination check, test verification
• 2 advisory gates activate when applicable — browser check (Lightpanda), design check (frontend files)
• Auto-QA (sub-agent) verifies code against spec — alignment, test coverage, error handling, boundary conditions, integration consistency, coding principles

Six independent sub-agent review points. The agent that writes the code — or diagnoses the bug — never reviews its own work alone.

Hybrid Loading

Most frameworks dump all instructions into the context window and hope for the best. Sage loads in two layers: the eager layer (process rules, workflow gates, engineering principles — ~200 lines, always in context) enforces what must never be skipped. The lazy layer (capabilities like TDD discipline, coding principles, systematic debugging, build-loop orchestration — loaded when the workflow step needs them) adds depth without bloating context. A focused agent with the right 500 tokens outperforms a distracted agent with 50,000 tokens of everything.

Session Resilience

Close your IDE, hit a context limit, come back tomorrow — Sage picks up exactly where you left off. A cycle manifest captures state, context summary, decisions, open questions, and handoff guidance at every checkpoint. Type /continue and Sage reads the manifest, routes to the correct workflow, and preserves the judgment context that would otherwise be lost.

Memory That Compounds

Most agent frameworks are stateless. The agent that made a mistake yesterday makes it again today. Sage has three skills that build institutional memory — all backed by sage-memory MCP: