accreted-intelligence

# Accreted Intelligence

[![Stars](https://img.shields.io/github/stars/maxbaluev/accreted-intelligence?style=flat&logo=github&color=f5c518)](https://github.com/maxbaluev/accreted-intelligence/stargazers)
[![License](https://img.shields.io/badge/license-Apache--2.0%20(repo%20glue)-blue)](LICENSE)
[![MCP](https://img.shields.io/badge/MCP-server-1f6feb)](https://modelcontextprotocol.io)
[![Official MCP Registry](https://img.shields.io/badge/MCP%20Registry-io.github.maxbaluev%2Faccint-1f6feb)](https://registry.modelcontextprotocol.io/v0.1/servers/io.github.maxbaluev%2Faccint/versions/latest)
[![Works with](https://img.shields.io/badge/works%20with-Claude%20Code%20·%20OpenCode%20·%20Codex%20·%20Cursor-7c3aed)](#install)
[![Platform](https://img.shields.io/badge/platform-Linux%20·%20macOS%20·%20Windows-555)](#install)
[![Live](https://img.shields.io/badge/live-accint.xyz-3fb950)](https://accint.xyz/?ref=github-readme&utm_source=github&utm_campaign=readme)

> Make your AI work compound. Offload the task. Never the learning.

AI agents are powerful but amnesiac: every run burns your tokens on real work, ships an output, then forgets. You **rent** capability — you never build it. `acc` changes the unit from a task that evaporates to an **investment that compounds**. Hand work to the agents you already run (Claude Code, Codex, OpenCode, Cursor), and **two things** compound into one owned asset — a **Work Model** of your business: your **intellect** (what you decide, what good looks like, what you'll never allow) and your **agents' tokens** (every verified path distilled into a runtime that replays instead of re-reasoning). It learns what actually worked, checked against your own results, and **predicts the better path before the next run starts**. It acts in your real accounts with a receipt for every step, holds anything that leaves your machine for your OK, and lets reality settle it. So the same job gets cheaper, faster, and genuinely better every time it runs. The learning is yours: **swap the model, keep the company veteran.** Your work turns into capital you own, on a machine you control.

```
predict the better path  →  act in your accounts, receipted  →  reality settles it  →  the Work Model sharpens
```

> **See it live: [accint.xyz](https://accint.xyz/?ref=github-readme&utm_source=github&utm_campaign=readme).** The commitments ledger settles in real time there, alongside the full story and a measured readout that updates as the system runs. The engine source is private; the binary installs in one line (below) and the building blocks are open. We say what's proven and what's young.

---

## Why this exists

A model that scores 90% on a benchmark today scores 90% tomorrow. It doesn't learn from deployment, doesn't track which of its outputs led to good outcomes, and doesn't remember last week's mistake. It generates intelligence and throws it away. You keep paying — in time and tokens — to rediscover what already worked.

Accreted Intelligence is a bet that this is temporary. The idea is to move learning out of model weights and into scored external state, where judgment compounds from contact with reality and the model becomes a replaceable processor rather than the place intelligence lives. **The reasoning engine is the part you can swap; the judgment it earned in your world is the part you keep.**

There's a gap in how the existing tools are positioned, and it's where `acc` sits. Memory remembers context. Observability shows traces. Automation runs playbooks. `acc` closes the learning loop: commitment, action, approval, outcome, reusable path — scored by results, audited on a ledger, and running fully on your hardware. And it does the one thing memory can't: it **predicts** the path most likely to work from everything that worked in your world before, then watches its own error.

`acc` is a working kernel for that thesis. It's a Recursive Language Model over a late-interaction scored-token memory: two verbs over one memory. Credit defaults to a weak prior, and only reality earns full weight.

---

## One universal workflow for everything

There is no separate mode for technical and non-technical work. The loop is identical whether you're shipping code or chasing invoices. Only the content of what's retrieved and acted on differs. You talk to your agent in plain words, and the domain lives in the content rather than the architecture.

| Job | Run 1 | What `acc` now predicts and replays |
|---|---|---|
| Ship a feature | reasons every step, runs the tests | the test that catches this class of bug, the path that passed |
| Source candidates | reads your ATS, ranks, drafts first-touches | the sourcing angle that got replies |
| Chase invoices | reads the ledger, drafts the nudge | which reminder cadence actually moves receivables |
| Monday client briefs | gathers, drafts, files | the brief shape each client reads |

*(Illustrative. The measured counts live at [accint.xyz](https://accint.xyz/?ref=github-readme&utm_source=github&utm_campaign=readme). These rows show the shape, not a benchmark.)*

Four different jobs, one set of primitives: **commitment → action → `HELD → your OK` → outcome → credited lesson.** The authority gate (`HELD → your OK`) is structural in every flow that touches the outside world. That gate is what makes the same loop safe for consequential work and not only for code.

Run it again next week and verified steps replay instead of re-reasoning. Most AI re-reasons every task from scratch, so you pay full price forever. `acc` predicts the path that worked and replays the verified steps, so the same job costs less every run and keeps dropping as it learns.

---

## Install

`acc` installs in one line. It runs the installer for your OS, which sets `acc` up on your machine:

```bash
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
```

Windows (PowerShell 5.1+):

```powershell
$env:ACC_INSTALL_REF='github-readme'; $env:ACC_INSTALL_SOURCE='ref=github-readme&utm_source=github&utm_campaign=readme'; irm https://raw.githubusercontent.com/maxbaluev/accreted-intelligence/main/bootstrap/install.ps1 | iex
```

**Official MCP Registry / MCPB:** AccInt is published as
[`io.github.maxbaluev/accint`](https://registry.modelcontextprotocol.io/v0.1/servers/io.github.maxbaluev%2Faccint/versions/latest)
with MCPB packages for macOS, Linux, and Windows. Use that registry entry when
you are installing through an MCPB-aware client, marketplace, or downstream MCP
directory. The one-line installer above remains the broadest path when you want
`acc hosts-sync` to wire Claude Code, Codex, Cursor, and OpenCode on the same
machine.

The installer probes your hardware, picks the embedder tier it can honestly run, downloads and verifies the matching release binary when available, starts a warm local daemon, and wires your agent's `.mcp.json`. The first run may download the embedder model (several GB) and take minutes. The installer reports the wait honestly and never pretends your hardware is bigger than it is.

> **Prefer to be walked through it?** Paste **one prompt** into whatever agent you already use — Claude Code, Codex, Cursor, or OpenCode — and it installs acc *with* you, explaining each step, pausing for consent at the boundary, and verifying against a machine-readable contract instead of guessing. The prompt is the same one on [accint.xyz](https://accint.xyz/?ref=github-readme&utm_source=github&utm_campaign=readme). See **[docs/install/with-agent.md](docs/install/with-agent.md)**.

Agent-guided install prompt for GitHub readers:

```text
Install AccInt for yourself - a local Work Model that learns what actually worked across my projects and predicts the better path, so you get better at my work over time. Use the attributed GitHub README installer for my OS:

macOS/Linux:
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

Windows PowerShell:
$env:ACC_INSTALL_REF='github-readme'; $env:ACC_INSTALL_SOURCE='ref=github-readme&utm_source=github&utm_campaign=readme'; irm https://raw.githubusercontent.com/maxbaluev/accreted-intelligence/main/bootstrap/install.ps1 | iex

Then run `acc hosts-sync` and tell me when `acc retrieve "what should I do next?"` works. Before running anything, state the trust boundary: public Apache-2.0 installer/docs/plugins/registry glue; proprietary local engine binary with private engine source; local Work Model data stays on my machine; opt-out anonymous telemetry is event names/source refs only, with no prompts, files, memory, or Work Model data. It is local: no account, no API key, and it asks before anything leaves my machine.
```

---

## What the loop looks like

Once installed, you watch the loop work end to end. This is what first contact looks like: a commitment created, the better path predicted from what worked before, a receipt written as the work happens, and a score that moves.

```
$ acc status                                  # health + your next step
$ acc --db acc.db act solve "draft the follow-up to last week's brief"

  commitment c-7f3 created   ·   predicted from 4 prior memos   [VERIFIED]
  drafted the follow-up, held for your OK                       [HELD → your OK]
  you approved · sent · the angle that worked is kept           [CREDITED]
```

A `solve` records a commitment, retrieves and predicts the path most likely to work, and returns either the artifact or a deliberation frame for the attached session to resolve. Every step is written down as it happens. It's a receipt, not a transcript reconstructed after the fact. Read what it wrote with `acc commitments` and `acc status`.

*(The same loop, animated, with the stat strip that updates as the syst