The design decision that separates this from a memory server is that a commitment closed on the model's own say-so is kept as weak evidence and never promoted — full credit needs a test, a human, or the world replying. That is what stops the system compounding from its own mistakes, and it is why the approval gate on outward actions is structural rather than a setting. The engine source is private, so evaluate it on what it does on your machine rather than on the code.
A local kernel that sits behind the agents you already run and keeps what they learn. Instead of storing conversation, it records a commitment, retrieves from a scored memory, acts, and then closes the loop with a real-world verdict — so paths that actually worked accumulate weight and get replayed rather than re-derived.
- Two tools, which are the entire interface: `acc_retrieve` reads memory by MaxSim over per-token multi-vectors and is natively multimodal, so it can look at an image
- `acc_act` does the rest through four operations — `solve` to recurse on a sub-goal, `exec` to run sandboxed code, `register` to store a reusable runtime, `outcome` to close a commitment with a verdict
- Decomposition as a side effect rather than an operation: when the reasoner cannot answer directly it solves a sub-question, and the tree of solves is the breakdown
- A transitions ledger that ranks which action is most likely to improve things next, and watches its own prediction error so a shift in your world is visible
- Verified paths saved as runtimes and scored like anything else — a flow that worked replays cheaply, one that broke loses its score
- Credit that reality has to earn: closing a commitment defaults to `self_graded`, a deliberately weak prior; full weight needs the owner's confirmation, a passing test, a reply from the world, or a runtime that exited clean
- A receipt written as the work happens, and CLI views over it — commitments with their status, and open deliberation frames waiting on you
No cloud memory account. One installer line on macOS and Linux, or the PowerShell equivalent on Windows; it probes your hardware, picks an embedder tier it can honestly run, verifies the release binary, starts a local daemon and wires your agent's `.mcp.json`. The first run may download several GB of embedder model and take minutes. Published to the MCP Registry as `io.github.maxbaluev/accint` with MCPB packages for macOS, Linux and Windows, which is the route for an MCPB-aware client; the installer is the broader path because `acc hosts-sync` wires Claude Code, Codex, Cursor and OpenCode on the same machine. The substrate is a local SQLite file and retrieval and prediction run locally. Anything that leaves the machine — sends, publishes, deploys, transfers, deletes, credentialed actions — needs owner authority and leaves a receipt. The installer, host adapters and docs are open; the memory, appraisal and credit engine is not.
One command — curl -fsSL https://raw.githubusercontent.com/maxbaluev/accreted-intelligence/main/bootstrap/install | ACC_INSTALL_REF=github-readme ACC_INSTALL_SOURCE='ref=github-readme&utm_source=github&utm_campaign=readme' sh