Maggy, srooter>'s open-source AI engineering harness.

Every task goes to the cheapest model that can actually do it.

• Each message is scored 1-10 for complexity and risk (the "blast score") and classified by task type, all locally, by a free Qwen3 classifier, so triage costs nothing.
• The score selects a tier: T0 Qwen3 (local) for classification and bulk ops, climbing through DeepSeek, Kimi, Gemini, Grok, and Codex, up to Claude Sonnet/Opus (T11 to T12) for architecture and security review. Roughly 80% of real work lands on the cheap-but-strong middle tiers.
• Budget-capped with auto-demotion: when an org nears its cap, routing steps down to cheaper tiers instead of blocking. Fatigue-aware and cascading, a failed call falls back down the chain.

Deterministic, intent-matched workflows, not just prompts.

• Protocols are YAML files (maggy/skills/protocols/). When your intent matches one ("push to git", "ship a feature"), Maggy runs the steps in order with real gates.
• Example, git-push: lint, typecheck, tests, stage, commit (with an AI-written message), push. Any failing step halts the protocol; nothing ships half-done.
• Drop a .yaml to add your own. 67 bundled skills cover Python, TypeScript, React, React Native, Flutter, Supabase, Stripe, Playwright, security, ADRs, and cross-agent delegation.

Tests tell you it passes; Telos tells you it fulfils its intent.

• Telos scores work on an Intent Fidelity Scale: IFS = F1 x F2 x F3 across three planes, Conformance (does it meet the written spec), Validation (does it do the right thing), and Integrity (is it sound and safe).
• The score is multiplicative: a zero in any single plane collapses the total to zero. You cannot pass by acing two planes and ignoring the third.
• Ships as a plugin, so it runs as part of the pipeline rather than as a manual afterthought.

A queryable code graph any harness can use over MCP.

• Cortex builds a code-property graph with 10 edge types, cyclomatic-complexity metrics, FTS5 full-text search, and bidirectional traversal, all in a single SQLite database.
• It exposes 15 MCP tools, so Claude Code, Codex, or any MCP client can ask structured questions ("what calls this", "what would this change break") instead of grepping.
• Benchmarked against plain codebase-memory approaches: graph traversal beats flat RAG for "why" and "blast radius" questions.

Run multiple agents on one repo without file conflicts.

• Concurrent agent sessions each get a Docker-isolated workspace, auto-provisioned when a second session starts.
• Because each agent works in its own isolated checkout, parallel work never clobbers another agent's files, the classic failure mode of running multiple agents on a shared repo.
• Isolation modes let you choose how strict the separation is for a given run.

Memory that survives compaction and persists across weeks.

• Mnemos is task-scoped memory with a four-dimension fatigue model and typed checkpoints. It ingests Claude Code session transcripts, scores how "hazy" each session is, and auto-checkpoints before context is lost.
• When context compacts, Mnemos restores the typed checkpoint instead of making you re-explain the task, freeing tokens while keeping the thread.
• Engram is the long-horizon layer: it persists architectural knowledge across weeks and handles seven distinct "amnesia" types so decisions do not evaporate between sessions.

Stores why code exists, not just what it is.

• The intent-augmented Code Property Graph records the reasoning behind code, ReasonNodes and constraints, alongside the structure.
• It detects drift across six dimensions, flagging when an implementation has wandered from its stated intent.
• And it prevents duplicate implementations: before building something new, the graph can tell you it already exists.

A six-agent TDD pipeline with enforcement that does not depend on remembering.

• Six roles run each feature: Lead, Quality, Security, Review, Merger, and Feature, a real pipeline, not one model doing everything.
• Stop-hooks enforce TDD: tests must pass before a task is considered done. No green, no merge.
• Quality gates are enforced per file, max 20 lines per function, 3 parameters, 2 nesting levels, and non-trivial changes require an ADR (reverse-engineered from git history if one is missing).