La contabilidad atrasada de un colegio privado, al día en una noche con un agente de IA y SlowBooks Pro; el gerente decide lo dudoso

En dos frases

Kris Collo usó un agente de IA y SlowBooks Pro, una aplicación de contabilidad local y gratuita con API, para poner al día los libros de un colegio privado: el agente descargó más de un año de extractos, clasificó más de 2.000 movimientos según lo que habían hecho antes los propios libros del colegio y solo preguntó al gerente por las pocas decenas que no supo ubicar. Lo replicable del caso no es el modelo, sino la regla: decide el historial, una persona decide el resto y cada respuesta se convierte en regla.

Quién lo hace y por qué importa

Kris Collo fundó MicroPact, una empresa de software para administraciones que, según su perfil de X, vendió a Tyler Technologies, y hoy lleva una tienda de alimentación en una isla mientras construye agentes de IA en su propio hardware. El 15 de octubre de 2026 contó que un amigo, socio de un colegio privado sin papel en la gestión diaria, había salido de una junta de socios con malas noticias: la contabilidad llevaba más de un año de retraso, el colegio «perdía dinero a chorros» y el gerente estaba quemado. Collo se ofreció a ayudar «con IA» y documentó el trabajo durante los cinco días siguientes.

El caso importa porque es la situación más frecuente en las finanzas de una pyme y la menos vistosa: nadie ha registrado nada en meses, el saldo del banco es el único informe de gestión y los dueños no ven la tendencia hasta que falta caja. Collo es usuario, no proveedor. No vende SlowBooks Pro ni el agente que usó, y ni el colegio ni sus socios se identifican. Todo lo que sigue sale de sus publicaciones, de la documentación de SlowBooks Pro y de nuestra prueba de la aplicación; ninguna cifra del colegio está auditada.

Es además el segundo testimonio de la misma persona. El 6 de octubre describió a «Erica», un agente que registra en QuickBooks, a través del navegador, los asientos, cheques y cargos de tarjeta de su tienda, concilia cada mes hasta diferencia cero y, cuando encuentra una categoría que no conoce, le pregunta y convierte la respuesta en regla. Dice que ese agente funciona entero en sus propias máquinas (GLM-5.3-Flash en dos ordenadores NVIDIA DGX Spark). Para el colegio no dice qué modelo usó, así que no damos por hecho que fuera el mismo.

Herramientas y arquitectura

Son dos piezas, en palabras de Collo: SlowBooks Pro, «software de contabilidad gratuito y local con una API completa que los agentes pueden manejar», y «un agente de IA capaz de abrir un navegador, entrar en las webs del banco y de las tarjetas y descargar los extractos y las imágenes de los cheques».

SlowBooks Pro 2026 es una aplicación de contabilidad de escritorio de Trent Von Holten que recrea el funcionamiento de QuickBooks 2003 Pro: partida doble, facturación, nóminas de EE. UU., conexiones bancarias e informes, con toda la empresa en un único archivo local. Cada instalación levanta una API REST local, documentada en /openapi.json; la versión 2.25.0, la que probamos, declara 586 operaciones. Los agentes se autentican con tokens con permisos acotados (readonly, bookkeeper, admin). Su modelo bancario es clave para este caso: las líneas de extracto importadas (OFX, QFX, CSV o SimpleFIN) esperan en una cola de revisión, las reglas bancarias solo proponen una cuenta y nunca contabilizan, y una persona (o un agente con permiso de escritura) añade o empareja cada línea antes de que llegue al libro mayor. La licencia es de código disponible, no de código abierto: gratuita para uso personal y uso interno de una empresa, incluida la contabilidad de tus propios clientes, pero no se puede vender ni ofrecer como servicio alojado. Collo la llama «open source»; en sentido estricto no lo es.

El agente con navegador sustituyó la parte más pesada de un atraso: entrar en tres cuentas bancarias y dos portales de tarjeta y descargar 48 extractos en PDF, 34 extractos de tarjeta y 250 imágenes de cheques. Collo dice que el banco solo lo frenó una vez. Las imágenes de los cheques importan porque llevan el nombre del beneficiario que el extracto muchas veces omite («cada cheque tenía un nombre»).

La regla de decisión es el núcleo. Collo escribió que «no quería que la IA se inventara su propia contabilidad»: un proveedor que aparece al menos tres veces, y en la misma cuenta al menos el 80 % de ellas en los libros del colegio, va a esa cuenta; lo que no está tan claro va al gerente con la mejor apuesta del agente y lo que suele ir ahí. Una respuesta se convierte en regla para la siguiente vez.

Cómo funciona, paso a paso

1. Diagnosticar antes de automatizar. El detonante fue una junta de socios: cuentas con más de un año de retraso y un consumo de caja que, al ritmo que Collo vio el primer día, vaciaría el banco en unos seis meses.
2. Reunir todos los documentos. El agente entró en cada portal de banco y tarjeta y descargó 15 meses de extractos y las imágenes de los cheques. En SlowBooks los mismos datos pueden llegar en archivos OFX, QFX o CSV, o por SimpleFIN, que es más seguro que dar a un agente la contraseña del banco.
3. Cargar la contabilidad. SlowBooks se instaló en local y los movimientos entraron durante la noche; Collo habla de más de 2.000 líneas.
4. Clasificar por historial, no por intuición. Mismo proveedor 3+ veces y 80 % en una cuenta: asignado. Si no: una pregunta al gerente con una respuesta propuesta.
5. Convertir respuestas en reglas. Cada respuesta se guarda para que ese proveedor no vuelva a necesitar a una persona. Collo dice que solo «unas pocas decenas» de 2.000 la necesitaron.
6. Leer cada línea. Como el agente revisó todos los movimientos en lugar de echarles un vistazo, aparecieron unos honorarios contables duplicados, una comisión bancaria mensual en una cuenta con saldo de seis cifras y suscripciones que seguían cobrando después de cancelarse.
7. Cerrar el año y explicarlo. Con los libros cerrados, el agente puso 15 meses uno al lado del otro y explicó las tendencias en lenguaje claro a unos socios que, como dice Collo, «son ante todo profesores».

Cópialo y adáptalo

Collo no ha publicado su agente, sus prompts ni sus scripts, así que nada de lo que sigue es suyo. Lo público es SlowBooks Pro: el repositorio github.com/VonHoltenCodes/SlowBooks-Pro-2026 (leímos el commit 17a2d10, versión v2.25.0), la guía de IA y una plantilla de instrucciones para agentes. La licencia de SlowBooks (Source Available License v2.0, © 2026 Trent Von Holten) cubre el software y su documentación y no es una licencia abierta estándar, así que enlazamos esos archivos y solo citamos unos pocos comandos; las instrucciones para el agente, el script y el prompt que siguen son plantillas de Agents Finance basadas en las publicaciones de Collo y en la documentación de SlowBooks, de uso y adaptación libres. El script se probó el 21 de octubre de 2026 con SlowBooks Pro v2.25.0 y datos inventados. El código es idéntico en la versión inglesa; sus comentarios y mensajes están en inglés.

Requisitos previos

• SlowBooks Pro instalado (instalador de Windows o macOS de la última versión, Docker o código fuente con Python 3) y la configuración inicial hecha por una persona.
• Un plan de cuentas que refleje cómo informa ya el negocio y una copia de seguridad del archivo de empresa antes de cualquier proceso masivo.
• Un token de API creado por el administrador en Settings → API Tokens con el rol bookkeeper (para el informe final basta readonly).
• Los extractos en OFX, QFX o CSV, o una conexión SimpleFIN. Mejor exportarlos que dejar que un agente entre en tu banco.
• Python 3.9 o posterior para el script (solo biblioteca estándar) y un agente de terminal que lea CLAUDE.md o AGENTS.md si quieres que el agente maneje la API.

Ejecutar SlowBooks Pro desde el código fuente (de INSTALL.md)

Los instaladores son el camino fácil. En Linux, la instalación nativa documentada termina con estos comandos; para una prueba local pon además APP_DEBUG=true en .env, como explica INSTALL.md, o el servidor redirigirá a 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

Instrucciones para el agente en un trabajo de atrasos (CLAUDE.md o AGENTS.md)

Parte de la plantilla oficial para agentes, que pide «discover endpoints from the spec; do not guess paths» (descubrir los endpoints en la especificación, sin adivinar rutas) y mostrar los errores tal cual en lugar de improvisar. Añade una sección como esta para el trabajo de atrasos.

# Trabajo de atrasos: clasificar líneas de extracto según el historial de la empresa

Plantilla de Agents Finance basada en las publicaciones de Kris Collo
(X, 15–20 oct. 2026) y en las instrucciones para agentes de SlowBooks Pro.
Adapta nombres y umbrales.

## Alcance
- Trabaja solo con el archivo de empresa que indique la persona. Pide antes
  una copia de seguridad.
- Usa el token de API que te dé la persona al empezar (rol: bookkeeper).
  No lo escribas en ningún archivo ni lo muestres.
- Puedes: importar extractos tras /api/bank-import/preview, proponer una
  cuenta en una línea de extracto (PATCH /api/banking/transactions/{id}),
  crear reglas bancarias con las respuestas (POST /api/bank-rules).
- NO puedes: añadir, emparejar, anular ni borrar asientos, cambiar la
  configuración, tocar periodos cerrados ni crear cuentas. Contabiliza
  una persona.

## Regla de clasificación
- Historial = líneas de extracto ya añadidas a los libros más cualquier
  archivo de historial que aporte la persona (payee, account_id).
- Un proveedor visto 3 o más veces con la misma cuenta en al menos el 80 %
  de ellas: propón esa cuenta.
- Todo lo demás: no adivines. Escríbelo en questions.csv con tu mejor
  apuesta y las cuentas a las que suele ir ese proveedor, y para.
- Cuando la persona responda, crea una regla bancaria de coincidencia
  exacta por proveedor.

## Informe final
- Recuentos: líneas propuestas, preguntas hechas, reglas creadas.
- Cualquier cosa rara que veas al leer cada línea: pagos duplicados,
  comisiones recurrentes, cargos después de una cancelación. Enuméralos,
  no los corrijas.

El script de historial de proveedores (vendor_rules.py)

Nuestra implementación de la regla. Por defecto solo simula, usa únicamente la biblioteca estándar y los endpoints documentados, y nunca contabiliza: guarda una cuenta propuesta en cada línea de extracto (lo que después contabiliza el botón Add all categorised) y escribe todo lo demás en questions.csv. El comando learn convierte el archivo respondido en reglas bancarias y las aplica a la cola.

#!/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)

Comandos del día a día

Los comentarios del bloque están en inglés, como en la versión original: 1) importar un extracto CSV con columnas de fecha, descripción e importe; 2) ver el plan y luego aplicar las propuestas; 3) el gerente rellena answer_account_id en questions.csv y las respuestas se convierten en reglas; 4) una persona revisa la cola y contabiliza las líneas categorizadas.

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 para el informe en lenguaje claro

Ejecútalo con un token readonly cuando todas las cuentas estén conciliadas.

Plantilla de Agents Finance basada en la publicación de Kris Collo del 20 oct. 2026.

Vas a preparar un informe en lenguaje claro de {{ORGANIZACION}} para unos
dueños que no son contables. Usa solo la API de SlowBooks Pro con el token de
solo lectura que te doy. Descubre los endpoints en /openapi.json.

1. Para cada mes de {{MES_INICIAL}} a {{MES_FINAL}}, lee
   GET /api/reports/profit-loss con start_date y end_date de ese mes.
2. Haz una tabla: mes, ingresos totales, la cuenta {{CUENTA_INGRESO_PRINCIPAL}},
   nóminas (sueldos + cargas sociales), alquiler, otros gastos, resultado.
3. Compara los mismos meses con el año anterior cuando existan ambos años.
   Da cada variación en porcentaje y muestra los dos importes de los que sale.
4. Calcula las nóminas como céntimos por cada unidad de {{CUENTA_INGRESO_PRINCIPAL}}.
5. Con GET /api/reports/balance-sheet?as_of_date={{FECHA_FINAL}}, toma la tesorería
   y estima los meses de caja como tesorería / salida neta media de los
   últimos 3 meses. Muestra la fórmula y los datos.
6. Enumera lo que parezca un pago duplicado, una comisión recurrente o un
   cargo posterior a una cancelación, con fechas e importes.
Escribe como máximo 10 viñetas breves y después la tabla. No redondees las
diferencias, no inventes causas y di «no está en los libros» cuando falte
un dato.

Un ejemplo concreto

En nuestro colegio inventado, cinco meses de historial ponían a una gestora de nóminas, un arrendador, un proveedor de comida y una papelería siempre en las mismas cuentas, salvo una compra de papelería que fue a herramientas (cinco de seis, un 83 %). Una suscripción de videoconferencias había aparecido una sola vez. Al llegar un mes nuevo, la simulación imprimió cuatro líneas como FILE 2025-08-01 -12500.00 'ACME PAYROLL SERVICES' -> 6110 Wages & Salaries (5/5) y escribió dos preguntas: la videoconferencia, con «6700 Telephone & Internet (1/1)» como mejor apuesta, y un proveedor nunca visto, sin apuesta. Rellenadas las respuestas, learn --apply creó dos reglas bancarias de coincidencia exacta y la cola mostró las seis líneas categorizadas pero todavía sin contabilizar. Nada llegó al libro mayor hasta que una persona pulsó Add.

Resultados que declara el autor

Todas las cifras salen de las publicaciones de Collo y no están auditadas. Las entradas: 48 extractos en PDF de 3 cuentas bancarias, 34 extractos de 2 tarjetas, 250 imágenes de cheques y más de 2.000 movimientos, al día en una noche. La carga humana: «unas pocas decenas» de los 2.000 necesitaron al gerente. Los hallazgos: unos honorarios contables duplicados, una comisión bancaria recurrente en una cuenta de seis cifras y cargos automáticos cancelados que seguían saliendo. La foto de gestión: matrículas del verano un 7,5 % por debajo del año anterior, nóminas un 6,3 % por encima en los mismos meses, nóminas equivalentes a 67 centavos de cada dólar de matrícula, el ingreso mensual domiciliado (que él llama la mejor señal de matriculación que tiene el banco) un tercio por debajo de su máximo y entre 3,5 y 4 meses de caja si no se puede renegociar el alquiler. Además, en una publicación habla de 15 meses de atraso y en otra de 18; recogemos ambas.

Limitaciones y riesgos

• Redes sociales, no un estudio de caso. No hay capturas de los libros, informes de conciliación ni firma de un contable. El colegio es anónimo, así que nada se puede comprobar de forma independiente.
• Rapidez no es exactitud. «En una noche» se refiere a la carga y la clasificación. Collo dice que el año quedó cerrado el 20 de octubre, cinco días después de empezar; no dice si cada cuenta se concilió con el saldo de su extracto ni si un contable revisó el ejercicio.
• Dejar que un agente entre en el banco supone darle credenciales y, a menudo, códigos de un solo uso. Las exportaciones, los archivos OFX o un agregador de solo lectura como SimpleFIN reducen ese riesgo.
• Los datos salen de la máquina salvo que el modelo sea local. La propia guía de SlowBooks advierte de que un agente de terminal que usa un modelo en la nube envía a su proveedor lo que lee de tus libros. Collo usa modelos locales en su tienda; para el colegio no lo dice.
• El historial puede estar mal. Una regla que copia la clasificación pasada copia también sus errores. Si los libros anteriores del colegio eran incoherentes, el umbral del 80 % solo protege en parte.
• Licencia y país. SlowBooks Pro es gratuito para tu contabilidad o la de tus clientes, pero no se puede revender ni ofrecer como servicio alojado. Prepara nóminas e impuestos de EE. UU.; fuera de ese país, comprueba qué te sirve: la regla de clasificación vale en cualquier sitio, los modelos fiscales no.

Errores comunes

• Umbrales demasiado laxos: con dos apariciones o un 60 %, las conjeturas se convierten en reglas. Empieza estricto y relájalo solo con datos.
• Comparar el texto bruto del beneficiario. Los procesadores de tarjeta añaden números de tienda y fechas («SQ *PROVEEDOR 1234»); normalízalos o usa una regla contains escrita por una persona.
• Dejar que el agente contabilice. Proponer una cuenta y añadir una línea son permisos distintos; el segundo, para una persona o para un paso aparte y revisado.
• Saltarse la copia de seguridad. SlowBooks guarda toda la empresa en un archivo; cópialo antes de cualquier proceso masivo.
• Pedir el informe antes de conciliar. Un informe en lenguaje claro sobre libros sin conciliar es fluido y erróneo.

Conclusiones

Lo interesante de la semana de Kris Collo en el colegio no es que un agente leyera 2.000 movimientos en una noche, sino el límite que eligió. Los libros deciden dónde va un proveedor conocido, la persona que lleva el negocio decide el resto una sola vez y la respuesta queda guardada como regla. Ese patrón no depende de ningún modelo concreto, y el diseño de SlowBooks Pro (API local, propuestas que nunca contabilizan, copia de seguridad en un solo archivo) facilita reproducirlo. Toma sus cifras como un testimonio creíble de primera mano, no como prueba; ensaya la regla con un mes que ya conozcas y deja a una persona en el botón que escribe en el libro mayor.