# SAGE: A Governance Loop Around a Frozen LLM, With Honest Claims and a Hard Edge Bet > SAGE wraps a frozen LLM in a 12-step identity, trust, and resource-governance loop. The ARC-AGI-3 score is real but carefully scoped; the real bet is whether small local models can gain capability from structure alone. **dp-web4/SAGE** — A cognition kernel that wraps a frozen LLM in a persistent identity + trust + governance loop — testing whether capability comes from structure, not weights. Research-stage; honest about what's real vs mocked. - Repository: https://github.com/dp-web4/SAGE - Stars: 28 · Forks: 6 - Language: Python - License: AGPL-3.0 - Published: 2026-08-24 · Updated: 2026-08-24 · Language: en - Canonical page: https://hysenlabs.com/projects/dp-web4-sage ## The Core Bet: Structure Over Weights SAGE is not another model. It is a Python kernel that wraps a frozen LLM in a persistent identity, trust, and resource-governance loop. The README states the bet directly: useful capability comes from the structure around a model, not from changing its weights. The project calls this 'intelligence through orchestration, not scale.' The target user is a researcher, not a product team. The repository is explicit that this is research-stage work, not a product. That framing matters because it shapes what you can expect. You are not getting a drop-in agent framework. You are getting a research environment for testing whether a continuous governance loop can turn a small local model into something more capable. ## The 12-Step Loop and Its Biological Metaphors The heart of SAGE is a continuous loop with 12 named steps, each with a biological or cognitive label. The loop runs forever: sense, attend, metabolize, posture, select, budget, execute, learn, remember, govern, filter, act. The 'metabolize' step tracks an ATP budget, borrowing from cellular energy accounting. 'Posture' computes trust from a sensor trust landscape with confidence, asymmetry, and breadth. 'Select' combines salience, metabolic rate, and posture weight. The loop is not a pipeline; it is a cycle where effects feed back into trust and memory. The pseudocode in the README shows the core: gather observations, score salience with SNARC, select plugins with IRP, invoke and refine, check policy, dispatch, then update trust and memory. That is a concrete mechanism you can trace. The biological language is evocative, but the actual logic is a resource allocation and policy enforcement loop. ## What Is Real vs. Mocked: The Trust Signal The strongest single signal in this repository is a table in the README that separates what is measured from what is mocked. The README calls this 'the strongest single trust signal.' That is rare in research-stage AI projects. It lists components like SNARC, IRP, and the consciousness loop, and flags which are actually implemented versus simulated for the current research phase. The project also keeps a public scorecard on ARC-AGI-3 with a 94.85% score. But the README is careful to attach two asterisks. First, that score came from a frontier model (Claude Opus 4.6) plus a task-specific Phase-1 harness, not from the edge-kernel thesis. Second, the harness had access to the games' public engine source, which a strict competition run would withhold. The local small-model continuation, the actual edge bet, is 'still near the noise floor' on the general scored benchmark. The project keeps these apart on purpose. That distinction is the most honest part of the whole repository. ## Getting It Running: Commands and Config The README does not provide a quickstart install command. It points to a docs directory with a system understanding file and a full consciousness loop spec. The repository layout includes `sage/docs/SYSTEM_UNDERSTANDING.md` and `sage/docs/UNIFIED_CONSCIOUSNESS_LOOP.md`. The core loop pseudocode is in the README itself, but actual configuration keys are not shown in the provided material. The project mentions 'raising session counts' and '21 configured SAGE instances' across 8 machines, but the exact configuration format is not in the visible README. To get it running, you would clone the repo and read the docs. The AGPL-3.0 license applies. There is no homepage, no release tags, and no package on PyPI in the material. So expect a source-level research setup, not a pip install. ## The ARC-AGI-3 Scorecard: What It Does and Does Not Prove The 94.85% score on ARC-AGI-3 is real and verifiable via a public scorecard link. But the README is explicit that it is not the edge-kernel thesis proven. It was earned by a frontier model with a task-specific harness that analyzed the games' public engine source to build per-game solver cartridges. That means the capability came from engine-level context and tooling, not from blind observation. The local small-model continuation, which is the actual edge bet, is 'earlier-stage' and 'still near the noise floor' on the general scored benchmark. This is a critical limitation. If you are evaluating SAGE for its claimed thesis, you must not cite the 94.85% as evidence for the structure-over-weights idea. The project itself warns against that conflation. That is a genuine failure mode: the headline number is impressive but misleading if taken out of context. ## Private Repos and the Disclosure Boundary The public repo contains the kernel architecture, the loop spec, the IRP plugin interface, the identity layer, the raising curriculum, and frozen snapshots. Active capability research continues in private repos: `dev-SAGE` for methodology and brain-architecture primitives, and `shared-context` for cross-machine fleet learning. The README states that public disclosure of subsequent local-LLM work is 'deferred to a date of our choosing.' That is a real constraint for adoption. You cannot see the current state of the actual edge bet. You can only see the architecture and the older snapshot. The project is honest about this, but it means the repository is incomplete as a basis for reproducing the claimed research direction. If you need to verify the current claims, you cannot, because the evidence is private. ## Alternatives and the Wrong Tool Cases The closest alternative is the Web4 repository, which the README describes as the open primitive that SAGE extends. Web4 provides the governance model; SAGE carries it onto edge hardware. That is a real difference in approach: Web4 is the base ontology stack, SAGE is the persistent agent loop on top. Other agent frameworks exist, but the README does not name them. If you need a general-purpose agent with a large model and no governance loop, SAGE is the wrong tool. Its entire premise is that the loop matters more than the model. If you need a production system, the research-stage label and private repos make it unsuitable. The mock-vs-real table is the first thing to check, because the README says some components are mocked. That means the loop may not be fully implemented as specified. ## Maintenance and License Implications The repository is under AGPL-3.0, which has network-use implications if you deploy it as a service. That is a licensing consideration, not legal advice. The project has 5,000+ commits and a census of 21 instances, but no recent releases are retrieved. The maintenance cadence is unclear from the material. The public repo is not archived, so it is active, but the active work is in private repos. That split means the public repo may lag behind the actual research. Upgrade cost is not documented. You would need to read the docs to understand how the loop spec maps to code. The README says the public repo contains 'frozen snapshots of research milestones,' so you should expect the code to be a point-in-time artifact, not a continuously updated package. ## Conclusion Adopt SAGE if you are a researcher exploring whether persistent structure, not weights, can produce useful cognition on edge hardware. Do not adopt it for production use; it is explicitly research-stage, with private repos holding the active capability work. Before engaging, verify the 'real vs mocked' tables in the README, confirm which components are simulated, and read the full consciousness loop spec. If you need a deployable agent framework, look elsewhere; if you want to test a governance-first cognition hypothesis, SAGE is a rare honest starting point. ## FAQ ### What does SAGE do that a plain LLM API call does not? It keeps identity, memory, learned state, evidence handling and governed action around a frozen model instead of rebuilding them on every prompt. Each instance carries identity across sessions and model changes, and action goes through explicit interfaces rather than model text. ### Can SAGE run on a Jetson device? The repository ships Dockerfile.jetson and Dockerfile.jetson.simple at its root, and the fleet hardware is described as spanning Jetson edge devices, laptops, workstations, Apple Silicon and society-host machines. Torch is an optional dependency behind the gpu extra rather than a required one. ### How do I install and test the sage-cognition package? The pyproject dev extra installs the test runner together with the libraries the tests import, which is what makes `pip install -e .[dev] && pytest` work; 70 test files import torch and 41 import transformers. pytest-timeout is included to kill hung model and hardware tests. ### Is all of the SAGE research published? No. The public repository holds the kernel architecture and a durable research record, while active capability research continues in private repositories including dev-SAGE, SWE-SAGE and shared-context. SWE-SAGE stays private during the active competition, with publication as a later deliberate promotion step. ## Sources - [Official README](https://github.com/dp-web4/SAGE#readme) - [Project repository](https://github.com/dp-web4/SAGE) - [README](https://github.com/dp-web4/SAGE/blob/main/README.md) - [Releases](https://github.com/dp-web4/SAGE/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/dp-web4-sage