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 — 37 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
Four independent sub-agent review points. The agent that writes the
code 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:
- Self-learning captures mistakes as WHEN/CHECK/BECAUSE prevention rules. Every session starts by searching past mistakes before doing anything.
- Memory stores project knowledge as focused prose insights — how your auth works, why billing uses event sourcing, what conventions the team follows.
- Ontology maps entity relationships — not just "billing exists" but "billing depends on payments, which triggers webhooks, which notify users." Touch one module, know the blast radius.
