Runs on your hardware·works with Claude, Cursor & Codex·early access
Make your AI workcompound.
Hand work to the AI agents you already run. AccInt learns what actually worked — checked against reality, shaped by how you decide — and predicts the better path before the next run starts. The same job gets faster, safer, and genuinely better each time. All on a machine you control.
the agent acts you see a receipt reality settles it next run starts from what worked
no spam · no calls · first invites go in order
ON THE LISTYour invite goes out in order — no spam in between.
Hmm, that didn't go through — retrying the classic way…
a commitment settling — Tuesday, 9:14:
SESSION LEDGERoperator: accint
08:50find41 candidates matched the brief — your ATS first, then LinkedInVERIFIED
08:58rankshortlist of 9 — each with a why + a warm pathVERIFIED
09:07draft9 personal first-touches — none templatedHELD → your OK
09:15send9/9 sent — each confirmed on the live pageVERIFIED
09:20keepATS updated: stage, notes, next step per candidateVERIFIED
+1d 06:30learn3 replies → the sourcing angle that worked shapes every run afterCREDITED
—refuse"blast 400 InMails" — consent floor, never crossedREFUSED
next: 2 candidates to re-engage before Friday
not a transcript after the fact — commitments are written as the work happens
LIVE
AccInt is running while you read this. The live wedge is concrete:
several coding-agent terminals, one local Work Model, one owner, approval before external action.
The broader product is a learning substrate for any agent-run job; the proof starts where agents already do real work.
where it starts
Best where the same work runs again.
If you already hand real work to agents — shipping code, research loops, recruiting and
sales pipelines, client briefs, finance and back-office tasks where a wrong move costs something — you keep
paying to rediscover what already worked. AccInt is for exactly that: the work that repeats, where getting
cheaper, safer, and better each run actually compounds. And the learning isn't trapped in one
task: it picks up the patterns in how your work actually goes — your tools, your preferences, the paths
that hold up — so new, related jobs start from that experience, not just the model's defaults.
RUN 2
starts from what worked
RUN N
verified replay — near-instant, near-free
verified steps replay instead of re-reasoning, and the next run starts from the better path — the same job costs less and lands better every run
you · agency recruiting · monday 08:35“Run the staff-platform-engineer search — my name is on every message, so quality only.”
RUN 1week one
08:42find47 engineers match — your ATS first, then GitHub + conference talksVERIFIED
08:58reada “why now” per person — repos, talks, job changesVERIFIED
09:16refuse“blast 400 InMails” — consent floor: 11 named people, never a listREFUSED
09:34draft11 first-touches — the Kestrel Labs one opens with her k8s-migration postmortemHELD → your OK
09:55send11/11 sent from your seat — each confirmed deliveredVERIFIED
10:07keepATS true: stage, source, next step — per candidateVERIFIED
08:12skipArclight’s staff eng: “happy till my March vest” in run 5 — re-engage thenKNOWN
08:14draft6 touches — both re-engages cite what changed since you last spokeHELD → your OK
08:17send6/6 + ATS true — the sourcing pass was verified replayVERIFIED
10:07filetwo submittals out to the client — a fee rides on eachVERIFIED
week nine: the Work Model paying out — 6 min of decisions, the rest verified replay
what it now knows about your world
run 2learnedseniors reply to postmortems, not perksCREDITED
run 4learnedthu 08–10 sends = 2.1× responseCREDITED
run 5learned“blast it” stays refused — named people onlyCREDITED
THE GAP
Memory remembers context. Observability shows traces. Automation runs playbooks.
AccInt closes the learning loop: commitment → action → approval → outcome → reusable path, scored by results,
audited on a ledger, running fully on your hardware.
every action leaves a receipt
When someone asks "why did it do that?", it's already written.
Most AI work leaves no trail — no record of what it expected, who approved it, or
whether it actually worked. AccInt writes every step down as it happens: the receipt your team can
show management, and the lesson the next run inherits. Same record, two readers.
management · thursday“why did Meridian’s CFO get two emails in March?”
Nothing happens without a trace, and nothing you decided is lost.
how it learns
It learns the way a brain does.
Your brain lights up what it has seen before, predicts what happens next in the
space of meaning, acts, and learns most from whatever surprised it. AccInt runs the same loop —
except every prediction is checked against reality, shaped by how you decide, and the whole memory
stays on your machine. The thing it learns from is one settled commitment: what the agent expected,
what it did, who approved it, what came back, and whether that path earned the right to be trusted again.
FIG. 1 · HOW JUDGMENT COMPOUNDSper token, not per document
The local model behind this page, counted on 12 Jun 2026:
WORLD MODEL READOUToperator: accint
holds2,778 entities in the local Work Model · 537 of them runnableCOUNTED
wrote20,667 events on the append-only ledgerCOUNTED
scored1,931 outcomes validated by reality · 372 self-graded, held at a weak priorCREDITED
ranlast 50 outcomes: 94% good — belief never counts as realityVERIFIED
live counts from the operator that builds and runs this very page
Khattab & Zaharia (2020). ColBERT: Efficient and Effective Passage Search via Contextualized Late Interaction over BERT. SIGIR. arXiv:2004.12832
Faysse et al. (2024). ColPali: Efficient Document Retrieval with Vision Language Models.arXiv:2407.01449
Thompson (1933). On the likelihood that one unknown probability exceeds another in view of the evidence of two samples. Biometrika. JSTOR:2332286
Friston (2010). The free-energy principle: a unified brain theory? Nature Reviews Neuroscience. nature.com/nrn2787
LeCun (2022). A Path Towards Autonomous Machine Intelligence. OpenReview. openreview:BZ5a1r-kVsf
the full argument and the math live in the
whitepaper.
the numbers above are measured, not promised: the built-in eval harness holds retrieval at
recall@5 = 1.000 against exact brute-force across the live Work Model, and the gates, nulls and
routing policy recalibrate themselves from real outcomes.
no new tool to adopt
It plugs into the tools you already run.
Keep using Claude, Cursor, Codex, or OpenCode. AccInt sits underneath them and gives
them the one thing they lack: a memory of what actually worked, on your hardware. And because the
reasoner can write its own runtimes, it doesn't stop at chat — it can drive the browser, a terminal,
or any tool you already use, and every one of those actions lands in the same scored record. Change the
agent later; what it learned stays yours.
Two things compound here, not one: what worked, and
how to do it. When the reasoner finds a path that holds — a browser flow, a script, a tool
integration — it saves it as a runtime, and reality scores that runtime exactly like a memo.
No privileged lane: the browser is just another scored runtime. A flow that worked replays cheaply
next time; one that broke loses its score and isn't trusted again.
RUNTIME LEDGERcapability, scored like everything else
writeruntime:portal-login — the reasoner wrote the flow onceVERIFIED
drivethe browser ran it on the live page — scored by what really happenedVERIFIED
replaythe verified flow — re-checked, not re-reasonedREPLAYED
debita flow that broke — score docked, not retried blindNOT TRUSTED
a browser flow, a script, a tool — every capability earns its score the same way
your hardware
No cloud brain to rent.
AccInt runs on a computer you control: one small program and one data file
(a pure-Rust binary and a SQLite file, for those keeping score). There is no cloud control plane in the loop
and no API key to leak: nothing reads your data except the operator itself.
The AI engine is replaceable, not the brain. What it learned lives in
the World Model, so you can swap the engine and keep all of it; the same local World Model already
runs under two different engines today.
In plain words: any recent computer runs it — stronger
hardware adds document and screenshot vision, modest machines run text-only.
DATA PLATE · ACCINT OPERATOR
DATA RESIDENCY
YOUR HARDWARE · ONE SQLITE FILE
REASONER
THE AGENT YOU ALREADY RUN · REPLACEABLE
EMBEDDER
LOCAL DAEMON · NO API KEY, EVER
AUTHORITY
SIGNED GRANTS · CONSENT FLOORS
RECORD
APPEND-ONLY LEDGER
LEARNING
PEDAGOGICAL RL · VERIFIED OUTCOMES
BASE TRAINING
NEVER ON YOUR DATA
HARDWARE LADDER · PROBED, NOT GUESSED
NVIDIA ≥10GB VRAM
COLQWEN3 8B AWQ · FULL MULTIMODAL
NVIDIA ≥5GB VRAM
COLQWEN3 4B AWQ · FULL MULTIMODAL
CPU · 24/12GB RAM
8B/4B ON CPU · SLOWER, MULTIMODAL
APPLE · 32/16GB
8B/4B BF16 ON MPS
BELOW THE FLOORS
LATEON · TEXT-ONLY
WINDOWS
NATIVE · CONTAINER AS FALLBACK
the installer probes VRAM, RAM and free disk, picks the rung, and prints the reason.
short a floor, it degrades one honest rung at a time; it never pretends your hardware is bigger than it is.
truth in roadmap
One world model today. A collective one tomorrow.
NOW · LIVE
Your world model
A working world model of your operation, on your machine — scored by real outcomes today, with your OK required before anything leaves. The readout above is it, running.
NEXT
Your team's world model
Many operators, one shared world model — per-person authority, one audit plane — so your team's experience compounds together, not in scattered chats.
HORIZON
Collective accreted intelligence
World models that compound peer-to-peer in vector space — each node re-verifying against its own reality, so the network gets smarter with no central brain to trust.
early access
Already running AI agents? Make them compound.
invites go in order — strongest fit first: teams already putting agents near real work
ON THE LISTYour invite goes out in order — no spam in between.
Hmm, that didn't go through — retrying the classic way…
