errata
sign up →

What is errata

A learning loop for AI coding agents — the fix your agent derived yesterday shouldn't cost the next agent an hour tomorrow.

Coding agents solve the same problems over and over. The dependency conflict your agent untangled yesterday gets re-derived from scratch today — by you, by a teammate, by the same agent in a fresh session. The reasoning that produced the fix evaporates the moment the context window closes.

errata keeps it. Problems, root causes, fixes, and the paths between them are recorded as a knowledge graph, and the next session starts primed with what previous sessions already learned.

The loop

Four stations, running continuously:

  1. Prime — before your agent works, errata injects relevant prior knowledge: problems seen before in this workspace, fixes that worked, patterns from the wider network.
  2. Work — your agent does its job. Nothing about your workflow changes.
  3. Learn — the local client watches real signals (failing commands, diagnostics, the edits that resolve them) and derives problem–fix knowledge automatically. Your agent can also witness things only it can see — a design constraint, a dead end ruled out — with lightweight inline tags.
  4. Compound — validated knowledge reinforces; superseded knowledge fades. The next agent, and the next teammate, starts sharper.

Two parts

The local client — a thin daemon on your machine. It observes your agent's work through harness hooks, keeps a local knowledge store, and is the privacy edge: raw code, file contents, and error text never leave the machine un-scrubbed, and nothing leaves at all until you opt in.

The Errata Network — the collective cloud graph. Contributions from many workspaces are deduplicated onto shared, canonical knowledge: hit the same failure anyone else has hit, and your agent lands on the accumulated understanding of it — causes, fixes that worked, fixes that didn't.

What gets captured

  • Problems (a failing build, a broken test, a diagnostic) in canonical form — stripped of machine-specific paths and identity.
  • The fixes that resolved them, correlated by cause, not guessed.
  • The reasoning your agent chooses to witness: constraints, failed attempts, patterns.

What never leaves your machine

  • Your source code and file contents.
  • Raw error text — only scrubbed, canonicalized signatures cross the wire.
  • Anything at all, until you turn on errata consent sync — collection is opt-in, per channel, default off.

Knowledge bound for the public network is additionally generalized at the door: organization-specific detail stays private to your scope, and the public graph receives the generalized lesson.

Where to go next