A private school’s 15-month bookkeeping backlog cleared overnight by an AI agent and SlowBooks Pro, with the GM as the human check

In two sentences

Kris Collo used an AI agent and SlowBooks Pro, a free local accounting app with an API, to bring a private school’s books up to date: the agent downloaded more than a year of statements, categorised over 2,000 transactions by what the school’s own books had done before, and asked the general manager only about the few dozen it could not place. What makes the case replicable is not the model but the rule: history decides, a person decides the rest, and every answer becomes a rule.

Who does it and why it matters

Kris Collo founded MicroPact, a government software company that his X profile says was sold to Tyler Technologies, and now runs a grocery store on an island while building AI agents on his own hardware. On 15 October 2026 he posted that a friend, part owner of a private school who is not involved in day-to-day management, had come out of a partners’ meeting with bad news: the accounting was over a year behind, the school was “bleeding money” and the general manager was burnt out. Collo offered to help, “going in with AI”, and documented the job over the following five days.

The case matters because it is the most common situation in small-business finance and the least glamorous: nobody has entered anything for months, the bank balance is the only management report, and the owners cannot see the trend until cash runs short. Collo is a user, not a vendor. He does not sell SlowBooks Pro or the agent he used, and the school and its partners are not named. Everything below comes from his posts, from the SlowBooks Pro documentation and from our own test of the open-source app; none of the school’s figures has been audited.

It is also a second data point from the same person. On 6 October he described “Erica”, an agent that posts his store’s journals, checks and card charges in QuickBooks through a browser, reconciles every month to zero and, when it meets a category it does not know, asks him and turns the answer into a rule. He says that agent runs entirely on his own machines (GLM-5.3-Flash on two NVIDIA DGX Spark computers). For the school he does not say which model drove the agent, so we do not assume it was the same one.

Tools and architecture

There are two pieces, in Collo’s own words: SlowBooks Pro, “free, local accounting software with a full API agents can drive”, and “an AI agent that can open a browser, log into the bank/credit card sites, and download the statements and check images”.

SlowBooks Pro 2026 is a desktop accounting app by Trent Von Holten that recreates the QuickBooks 2003 Pro workflow: double-entry books, invoicing, US payroll, bank feeds and reports, with the company kept in a single local file. Every install runs a local REST API, self-documented at /openapi.json; version 2.25.0, the one we tested, declares 586 operations. Agents authenticate with scoped tokens (readonly, bookkeeper, admin). Its banking model matters for this case: imported statement lines (OFX, QFX, CSV or SimpleFIN) wait in a review queue, bank rules only suggest a category and never post, and a person (or an agent with write rights) adds or matches each line before it reaches the ledger. The licence is source-available rather than open source: free for personal and internal business use, including keeping the books of your own clients, but it cannot be sold or offered as a hosted service. Collo calls it “open source”; strictly speaking it is not.

The browser agent replaced the most tedious part of a backlog: logging into three bank accounts and two card portals and downloading 48 bank PDFs, 34 card statements and 250 check images. Collo says the bank throttled it only once. The check images matter because they carry the payee name that a bank statement often omits (“Every check had a name”).

The decision rule is the core. Collo wrote that he “didn’t want AI making up its own accounting”, so a vendor seen at least three times, and placed in the same category at least 80% of the time in the school’s own books, is filed there; anything less sure goes to the general manager with the agent’s best guess and what usually goes there. One answer becomes a rule for next time.

How it works, step by step

1. Diagnose before automating. The trigger was a partners’ meeting: accounts more than a year behind and a cash burn that, at the run rate Collo saw on day one, would empty the bank in about six months.
2. Collect every source document. The agent logged into each bank and card portal and downloaded 15 months of statements and the check images. In SlowBooks the same data can also arrive as OFX, QFX or CSV files, or through SimpleFIN, which is safer than giving an agent your banking password.
3. Load the books. SlowBooks was installed locally and the transactions went into it overnight; Collo reports more than 2,000 lines.
4. Categorise by history, not by guess. Same vendor 3+ times and 80% in one category: filed. Otherwise: a question to the general manager with a proposed answer.
5. Turn answers into rules. Each answer is stored so the same vendor never needs a human again. Collo says only “a few dozen” of 2,000 needed one.
6. Read every line. Because the agent reviewed every transaction rather than skimming, it surfaced a duplicate accounting fee, a monthly bank fee on an account with a six-figure balance and subscriptions that kept charging after being cancelled.
7. Close the year and explain it. With the books closed, the agent laid 15 months side by side and wrote the trends in plain English for partners who, as Collo puts it, “are teachers first”.

Copy and adapt

Collo did not publish his agent, prompts or scripts, so nothing below is his. What is public is SlowBooks Pro: the repository at github.com/VonHoltenCodes/SlowBooks-Pro-2026 (we read commit 17a2d10, release v2.25.0), the AI Setup Guide and an agent instructions template. The SlowBooks licence (Source Available License v2.0, © 2026 Trent Von Holten) covers the software and its documentation and is not a standard open licence, so we link those files and quote only a few short commands; the agent instructions, script and prompt below are Agents Finance templates based on Collo’s posts and the SlowBooks documentation, free to use and adapt. The script was tested on 21 October 2026 against SlowBooks Pro v2.25.0 with synthetic data.

Prerequisites

• SlowBooks Pro installed (Windows or macOS installer from the latest release, Docker, or source with Python 3) and first-run setup done by a person.
• A chart of accounts that matches how the business already reports, and a backup of the company file before any batch work.
• An API token made by the administrator in Settings → API Tokens with the bookkeeper role (the readonly role is enough for the final review).
• Statements as OFX, QFX or CSV files, or a SimpleFIN connection. Prefer exports to letting an agent log into your bank.
• Python 3.9 or later for the script (standard library only) and an agentic CLI that reads CLAUDE.md or AGENTS.md if you want the agent to drive the API.

Run SlowBooks Pro from source (from INSTALL.md)

The installers are the easy path. On Linux, the documented native install ends with these commands; for a local test also set APP_DEBUG=true in .env, as INSTALL.md explains, or the server redirects to HTTPS.

git clone https://github.com/VonHoltenCodes/SlowBooks-Pro-2026.git
cd SlowBooks-Pro-2026
python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env
alembic upgrade head
python scripts/seed_database.py
python run.py

Agent instructions for a backlog job (CLAUDE.md or AGENTS.md)

Start from the official agents template, which tells agents to “discover endpoints from the spec; do not guess paths” and to show errors verbatim instead of improvising. Append a section like this one for the backlog job.

# Backlog job: categorise statement lines by the company's own history

Agents Finance template based on Kris Collo's posts (X, 15–20 Oct 2026)
and the SlowBooks Pro agent instructions. Adapt names and thresholds.

## Scope
- Work only on the company file named by the human. Ask for a backup first.
- Use the API token the human gives you at runtime (role: bookkeeper).
  Never write it to a file and never print it.
- You may: import statement files after /api/bank-import/preview, suggest a
  category on a statement line (PATCH /api/banking/transactions/{id}),
  create bank rules from the human's answers (POST /api/bank-rules).
- You may NOT: add, match, void or delete postings, change settings,
  touch closed periods or create accounts. A person adds the lines.

## Categorisation rule
- History = statement lines already added to the books plus any history
  file the human provides (payee, account_id).
- A payee seen 3 or more times with the same account in at least 80% of
  them: suggest that account.
- Anything else: do not guess. Write it to questions.csv with your best
  guess and the accounts this payee usually goes to, and stop.
- When the human answers, create one exact-match bank rule per payee.

## Report back
- Counts: lines suggested, questions asked, rules created.
- Anything odd you saw while reading every line: duplicate payments,
  recurring fees, charges after a cancellation. List them, do not fix them.

The vendor-history script (vendor_rules.py)

Our implementation of the rule. It is dry-run by default, uses only the standard library and the documented endpoints, and never posts to the ledger: it saves a suggested category on each statement line (what the Add all categorised button later posts) and writes everything else to questions.csv. The learn command turns the answered file into bank rules and applies them to the queue.

#!/usr/bin/env python3
"""Vendor-history categoriser for SlowBooks Pro statement lines.

Agents Finance template based on the rule Kris Collo described on X
(same vendor 3+ times, same category 80% of the time -> file it;
anything less sure -> ask a human; the answer becomes a rule).
Standard library only. Dry run by default: nothing is written unless
you pass --apply. It only SUGGESTS categories (PATCH on the statement
line) and creates bank rules; it never posts to the ledger.

  export SLOWBOOKS_URL=http://127.0.0.1:3001
  export SLOWBOOKS_TOKEN=sbp_...   # Settings -> API Tokens, role "bookkeeper"
  python3 vendor_rules.py suggest [--history-csv history.csv] [--apply]
  python3 vendor_rules.py learn questions.csv [--apply]
"""
import argparse
import csv
import json
import os
import re
import sys
import urllib.error
import urllib.request
from collections import Counter, defaultdict

BASE = os.environ.get("SLOWBOOKS_URL", "http://127.0.0.1:3001").rstrip("/")
TOKEN = os.environ.get("SLOWBOOKS_TOKEN", "")
MIN_COUNT = 3      # same vendor seen at least 3 times...
MIN_SHARE = 0.80   # ...with the same category at least 80% of the time
PAGE = 500


def api(method, path, body=None):
    data = json.dumps(body).encode() if body is not None else None
    req = urllib.request.Request(BASE + path, data=data, method=method)
    req.add_header("Authorization", f"Bearer {TOKEN}")
    if data is not None:
        req.add_header("Content-Type", "application/json")
    try:
        with urllib.request.urlopen(req) as r:
            return json.loads(r.read() or b"null")
    except urllib.error.HTTPError as e:
        # House rule: show the error verbatim and stop, never improvise.
        sys.exit(f"{method} {path} -> {e.code}: {e.read().decode()}")


def lines(status):
    out, skip = [], 0
    while True:
        page = api("GET", f"/api/banking/transactions?status={status}&skip={skip}&limit={PAGE}")
        out += page
        if len(page) < PAGE:
            return out
        skip += PAGE


def norm(payee):
    return re.sub(r"\s+", " ", (payee or "").strip().lower())


def history(csv_path):
    """payee -> Counter(category account id) from lines already in the books."""
    h = defaultdict(Counter)
    for status in ("added", "manual", "auto"):
        for ln in lines(status):
            if ln.get("payee") and ln.get("category_account_id"):
                h[norm(ln["payee"])][ln["category_account_id"]] += 1
    if csv_path:  # e.g. a vendor/account export from the previous system
        with open(csv_path, newline="") as f:
            for row in csv.DictReader(f):
                h[norm(row["payee"])][int(row["account_id"])] += 1
    return h


def suggest(args):
    accounts = {a["id"]: f'{a["account_number"]} {a["name"]}' for a in api("GET", "/api/accounts")}
    h = history(args.history_csv)
    pending = [ln for ln in lines("unmatched") if not ln.get("category_account_id")]
    filed, ask = [], []
    for ln in pending:
        seen = h.get(norm(ln["payee"]), Counter())
        total = sum(seen.values())
        best, n = (seen.most_common(1)[0] if seen else (None, 0))
        if total >= MIN_COUNT and n / total >= MIN_SHARE:
            filed.append((ln, best, n, total))
        else:
            ask.append((ln, best, n, total, seen))
    for ln, best, n, total in filed:
        print(f'FILE  {ln["date"]} {ln["amount"]:>10} {ln["payee"]!r} -> {accounts[best]} ({n}/{total})')
        if args.apply:
            api("PATCH", f'/api/banking/transactions/{ln["id"]}', {"category_account_id": best})
    with open(args.questions, "w", newline="") as f:
        w = csv.writer(f)
        w.writerow(["line_id", "date", "amount", "payee", "best_guess", "usually", "answer_account_id"])
        for ln, best, n, total, seen in ask:
            usually = "; ".join(f"{accounts[a]} x{c}" for a, c in seen.most_common(3))
            guess = f"{accounts[best]} ({n}/{total})" if best else ""
            w.writerow([ln["id"], ln["date"], ln["amount"], ln["payee"], guess, usually, ""])
    mode = "applied" if args.apply else "dry run, nothing written"
    print(f"{len(filed)} filed by history, {len(ask)} questions in {args.questions} ({mode})")


def learn(args):
    existing = {norm(r["pattern"]) for r in api("GET", "/api/bank-rules")}
    new = {}
    with open(args.answers, newline="") as f:
        for row in csv.DictReader(f):
            if row["answer_account_id"].strip():
                new[norm(row["payee"])] = int(row["answer_account_id"])
    for payee, account_id in new.items():
        if payee in existing:
            print(f"SKIP  rule for {payee!r} already exists")
            continue
        print(f"RULE  {payee!r} -> account {account_id}")
        if args.apply:
            api("POST", "/api/bank-rules", {"name": f"Learned: {payee}"[:100], "pattern": payee,
                                            "account_id": account_id, "rule_type": "exact"})
    if args.apply:
        print("apply:", api("POST", "/api/bank-rules/apply"))
    else:
        print("dry run, nothing written")


p = argparse.ArgumentParser()
sub = p.add_subparsers(dest="cmd", required=True)
s = sub.add_parser("suggest")
s.add_argument("--history-csv")
s.add_argument("--questions", default="questions.csv")
s.add_argument("--apply", action="store_true")
s.set_defaults(fn=suggest)
l = sub.add_parser("learn")
l.add_argument("answers")
l.add_argument("--apply", action="store_true")
l.set_defaults(fn=learn)
args = p.parse_args()
if not TOKEN:
    sys.exit("Set SLOWBOOKS_TOKEN (Settings -> API Tokens).")
args.fn(args)

Day-to-day commands

export SLOWBOOKS_URL=http://127.0.0.1:3001
export SLOWBOOKS_TOKEN=sbp_xxxxxxxx          # bookkeeper token, never commit it

# 1. Import a statement (CSV with date, description and amount columns)
curl -s -H "Authorization: Bearer $SLOWBOOKS_TOKEN" \
  -F file=@statement.csv "$SLOWBOOKS_URL/api/bank-import/import-csv/1"

# 2. Plan, then apply the suggestions
python3 vendor_rules.py suggest
python3 vendor_rules.py suggest --apply

# 3. The GM fills answer_account_id in questions.csv; turn answers into rules
python3 vendor_rules.py learn questions.csv
python3 vendor_rules.py learn questions.csv --apply

# 4. A person reviews the queue and adds the categorised lines (UI: "Add all categorised")
curl -s -H "Authorization: Bearer $SLOWBOOKS_TOKEN" \
  "$SLOWBOOKS_URL/api/banking/transactions?bank_account_id=1&status=unmatched"

Prompt for the plain-English review

Run it with a readonly token once every account is reconciled.

Agents Finance template based on Kris Collo's 20 Oct 2026 post.

You are preparing a plain-English review of {{ORGANISATION}} for owners
who are not accountants. Use only the SlowBooks Pro API with the read-only
token I give you. Discover endpoints from /openapi.json.

1. For each month from {{START_MONTH}} to {{END_MONTH}}, read
   GET /api/reports/profit-loss with that month's start_date and end_date.
2. Build a table: month, total revenue, the {{MAIN_REVENUE_ACCOUNT}}
   account, payroll (wages + payroll taxes), rent, other expenses, net.
3. Compare the same months year on year where both years exist. Report
   each change as a percentage and show the two amounts it comes from.
4. Compute payroll as cents per dollar of {{MAIN_REVENUE_ACCOUNT}}.
5. From GET /api/reports/balance-sheet?as_of_date={{END_DATE}}, take cash and
   estimate months of runway as cash / average net outflow of the last
   3 months. Show the formula and the inputs.
6. List anything that looks like a duplicate payment, a recurring fee
   or a charge after a cancellation, with dates and amounts.
Write at most 10 short bullet points, then the table. Do not round away
differences, do not invent causes, and say "not in the books" when a
figure is missing.

A worked example

On our synthetic school, five months of history put a payroll provider, a landlord, a food supplier and an office-supplies shop in the same accounts every time, except one office-supplies purchase that went to tools (five out of six, 83%). A conferencing subscription had appeared once. When a new month arrived, the dry run printed four lines like FILE 2025-08-01 -12500.00 'ACME PAYROLL SERVICES' -> 6110 Wages & Salaries (5/5) and wrote two questions: the conferencing tool, with “6700 Telephone & Internet (1/1)” as its best guess, and a vendor never seen before, with no guess at all. After we filled in the answers, learn --apply created two exact-match bank rules and the queue showed all six lines categorised but still unposted. Nothing reached the ledger until a person pressed Add.

Results stated by the author

All figures come from Collo’s posts and are unaudited. The inputs: 48 PDF statements from 3 bank accounts, 34 card statements from 2 cards, 250 check images and more than 2,000 transactions, caught up overnight. The human load: “a few dozen” of the 2,000 needed the general manager. The findings: a duplicate accounting fee, a recurring bank fee on a six-figure account and cancelled automatic charges still going out. The management picture: summer tuition down 7.5% year on year, payroll up 6.3% over the same months, payroll at 67 cents of every tuition dollar, the monthly autopay deposit (which he calls the bank’s best sign of enrolment) down about a third from its high, and 3.5 to 4 months of runway if rent cannot be renegotiated. He also writes that the backlog was 15 months in one post and 18 months in another; we report both.

Limitations and risks

• Social media, not a case study. There are no screenshots of the books, no reconciliation reports and no accountant’s sign-off. The school is anonymous, so nothing can be checked independently.
• Speed is not accuracy. “Overnight” describes the loading and categorisation. Collo says the books were closed for the year by 20 October, five days after he started; he does not say whether each account was reconciled to its statement balance or whether an accountant reviewed the year.
• Letting an agent log into banks means handing it credentials and, often, one-time codes. Exports, OFX files or a read-only aggregator such as SimpleFIN reduce that risk.
• Data leaves the machine unless the model is local. SlowBooks’ own guide warns that a cloud-backed CLI sends what it reads from your books to its provider. Collo runs local models for his store; for the school he does not say.
• History can be wrong. A rule that copies past categorisation also copies past mistakes. If the school’s earlier books were inconsistent, the 80% threshold protects you only partly.
• Licence. SlowBooks Pro is free to use for your own or your clients’ books but cannot be resold or offered as a hosted service. It prepares US payroll and tax forms; outside the US, check what applies.

Common mistakes

• Thresholds too loose: two occurrences or a 60% share turns guesses into rules. Start strict and relax only with evidence.
• Matching on raw payee strings. Card processors add store numbers and dates (“SQ *VENDOR 1234”); normalise them or use a contains rule written by a person.
• Letting the agent post. Suggesting a category and adding a line are different permissions; keep the second with a human or a separate, reviewed step.
• Skipping the backup. SlowBooks keeps the whole company in one file; copy it before any batch run.
• Asking for the narrative before reconciling. A plain-English report on unreconciled books is fluent and wrong.

Conclusions

The interesting part of Kris Collo’s week at the school is not that an agent read 2,000 transactions overnight; it is the guardrail he chose. The books decide where a known vendor goes, the person who runs the business decides the rest once, and the answer is stored as a rule. That pattern needs no particular model, and SlowBooks Pro’s design (a local API, suggestions that never post, one-file backups) makes it straightforward to reproduce. Treat his figures as a credible first-hand account rather than evidence, test the rule on a month you already know, and keep a person on the button that writes to the ledger.