Git remembers what changed. Scholion remembers why.

Git keeps snapshots and throws the reasoning away.

Put several coding agents on one repository and they hit the same three walls, over and over. Each one costs turns, time, and sometimes a broken main. Pasting more of the repo into the prompt doesn't fix it: the context window fills up before the agent knows what matters.

Tasks instead of branches. Notes instead of amnesia.

A daemon owns all state; the av CLI and the MCP tools are thin clients. Agents keep editing files with the tools they already use.

$ av task start --repo api \
    --goal "retry embedder calls"

$ av record --kind attempt \
    --summary "tenacity: not installed" \
    --anchor shared/text.py:embed

$ av context        # 800 tokens
$ av handoff --done "retries" \
    --remaining "429 tests"

$ av submit --record \
    "decision: honour Retry-After @ shared/text.py:embed"
$ av merge
$ av why shared/text.py:17

Task

One unit of agent work, replacing branch + pull request. Own workspace, own lifecycle: open, handed off, in review, merged.

Record

A short typed note: intent, decision, attempt, note, handoff, review. Append-only; a newer record supersedes an older one.

Anchor

A record's link to code. The anchored code's hash is stored, so a pack says (changed since recorded) once that code moves on.

Convention

A repo rule scoped by path glob, shown only to tasks touching matching files. Required ones always make the pack.

Session ledger

Remembers what each agent session was already sent, so later packs refer back instead of resending.

Receipt

Every pack is stored as rcp:<8 hex>: what was sent, at which tier and why. Records can cite the receipt their author worked from.

More of what matters. Never more than fits.

## Task
# Add retry · add-retry · open
Goal: retry embedder calls with backoff
Changed (1): shared/text.py

## Map
- shared/text.py
  L12: def embed(texts: list[str]) -> list[Vec]:
- shared/errors.py
  L4: class RateLimited(Exception):
  L9: class EmbedderDown(Exception):

## Decisions & dead ends
- rec:3f9a12c4 attempt: tried tenacity; not installed
  anchors: shared/text.py:embed
- rec:b71e0d55 decision: honour Retry-After first
- rec:0c44e9a1 note: batch size capped at 64
  (changed since recorded)

## Code
- sym:41 embed (shared/text.py:12-19)
  def embed(texts: list[str]) -> list[Vec]:
- ↩ sym:7 (sent earlier)

## Conventions
- conv:2 (shared/**) required: no new runtime deps

## Live work
- ⚠ live:batch-embed also touches shared/text.py
  (owner codex; "Batch embed requests")
---
tokens: 1184/2000

Built for swarms, not for a single chat window.

Handoffs carry what's done, remaining, broken and open. Claims are fenced by a generation number, so a stale agent's late write is refused with "claim lost" instead of clobbering the new owner's work. Each agent CLI is a team with its own cap on open tasks: at the cap it only reviews, merges and resumes its own work, and the dashboard shows who is full, who is idle and what each team is good at.

av agent set claude --best code,tests --cost 4
av agent set grok --best image --can ui,docs --cost 2
av post --repo api --title "Draw the logo" \
  --goal "…" --needs image

Works with the agents you already run.

Install, then run av init in your repository: it starts the daemon with its own Postgres on 127.0.0.1:7420, adds the repository and wires Claude Code. No Docker needed; deploy/docker-compose.yml adds semantic search. Then connect your other agents one of three ways. Where an agent has hooks, use them: no tool schemas sit in its context, and it closes a task in one av submit --record … call.

integrations/claude-code/install.sh

av init --for codex --for cursor \
  --for grok --for gemini

integrations/generic/av-wrap.sh \
  your-agent --task "…"

# 1. install; in your repo, start the daemon (:7420)
curl -fsSL https://raw.githubusercontent.com/vinhqbui/scholion/main/scripts/install.sh | sh
cd api && av init

# 2. a task by hand: its own workspace and a pack
av task start --repo api --title "Add retry" \
  --goal "retry embedder calls with backoff"
cd ~/ws/api/add-retry
av context                              # 800 tokens

# 3. or post it; the agent that fits takes it
av post --repo api --title "Add retry" --goal "…" --needs code
# watch at http://localhost:7420/ui

Community is what you can run. Commercial is not here yet.

Scholion today is the Community edition: free and MIT. Scholion Cloud, the hosted Commercial edition, is not available yet. Commercial has no price, because there is nothing to buy.

av --agent muse init --for mcp-json \
  --path PATH/TO/settings.json

We publish the numbers, including the ones that sting.

Scholion ships with its own benchmark harness. Every run, task set and analysis script is in the repo, so you can reproduce it, or prove us wrong.

Pick a margin. Leave a note.

Rust 2024, a Cargo workspace of focused crates, TDD all the way down. Humans and agents both welcome; if your agent writes the PR, say so.