Coram AI lleva QuickBooks Online con scripts hechos con Claude Code, una copia diaria del mayor en Supabase y agentes que solo avisan

En dos frases

Alex Altman, que lleva las finanzas de la empresa de videovigilancia Coram AI con un solo contable, usó Claude Code para convertir QuickBooks Online en algo parecido a un pequeño ERP: scripts que contabilizan asientos de cierre revisados, una copia diaria de todo el libro mayor en una base de datos, estados consolidados con controles y un equipo de agentes que vigilan la contabilidad y solo hablan cuando algo cambia. Lo que más merece la pena copiar es su regla: Claude construye el sistema, pero las cifras las produce código determinista, y los agentes solo avisan.

Quién lo hace y por qué importa

Coram AI vende videovigilancia y control de accesos con IA, con buena parte de su actividad en colegios. Altman dice que la empresa cerró una ronda de 35 millones de dólares en 2026 y que el área financiera son dos personas, él y un contable; con otras tres personas cubren también legal, recursos humanos, operaciones, inventario y envíos. La empresa trabaja con QuickBooks Online, con más de una empresa (sociedad) en QuickBooks y al menos una fuera del dólar.

Lo ha contado en una serie de artículos de su Substack (marzo a mayo de 2026) y en una sesión en directo de 40 minutos para la comunidad CFO Connect, donde enseñó las herramientas con datos ficticios. No vende software; las cifras son suyas.

Hay tres motivos por los que el caso es útil para un equipo financiero que trabaja con QuickBooks:

• Son herramientas corrientes de pyme, sin NetSuite, consultores ni equipo de datos.
• Separa construir de ejecutar. Altman lo dice claro: no confía en que Claude manipule sus estados financieros, sino en que Claude construya un sistema que lo haga. En la sesión añade que, una vez construido, Claude no interviene en el circuito de datos.
• Enseña el orden de trabajo: datos, cálculos deterministas, consolidación con controles y, al final, agentes.

Herramientas y arquitectura

El sistema, tal como lo describen los artículos y la sesión:

• QuickBooks Online por API. Un conector de automatización de terceros no servía para descargar un mayor de más de 50.000 movimientos, así que pidió claves de producción en el portal Intuit Developer, que exige un cuestionario de evaluación de la app incluso para una app privada de uso interno. Hizo que Claude Cowork lo rellenara como agente de navegador; dice que la aprobación fue inmediata. Las claves fueron a Claude Code.
• Supabase como base de datos financiera. Se la propuso Claude Code al construir la consolidación. Una tarea programada descarga cada día todas las líneas del mayor de las dos empresas de QuickBooks (unas 60.000) y vuelve a revisar los periodos anteriores, no solo los movimientos nuevos.
• Scripts deterministas. El reconocimiento de ingresos lee la facturación de Tabs (por su API) y las operaciones ganadas de HubSpot, calcula el ingreso por cliente y línea de producto, prepara el asiento y lo contabiliza en QuickBooks tras una pantalla de revisión. El mismo patrón cubre ya el coste de ventas, los gastos anticipados y la amortización del inmovilizado. Cada ejecución genera un Excel con el resumen de ingresos, el asiento y la cascada de ingresos diferidos, que se guarda en la carpeta del cierre para los auditores.
• Consolidación. Unas tablas de correspondencia (puente entre planes de cuentas, agrupaciones resumidas, etiqueta de estado financiero, departamentos y una tabla de tipos de cambio con la media del mes y el cierre) generan la cuenta de resultados, el balance y el estado de flujos de efectivo indirecto consolidados, con selectores de sociedad, año fiscal o natural y periodo.
• Un portal. Un ingeniero lo publicó en un día en Vercel con el inicio de sesión único de Google y módulos restringidos desde la base de datos.
• Agentes en Slack. Cada uno vigila un área, tiene su propio calendario y su propio CLAUDE.md con sus responsabilidades, fuentes y reglas de aviso; el de desviaciones lee sus umbrales de un policy.yaml.

El equipo de agentes

Altman describe un pequeño organigrama:

• Agente de proveedores. Para cada factura y gasto con tarjeta comprueba si hay contrato del proveedor en Google Drive, si la cuenta contable es distinta de la usada antes con ese proveedor y si el importe se sale de lo habitual. El prompt que cambió el diseño fue pedir que la comprobación de la cuenta dijera simplemente que era «una cuenta distinta de la de la última factura», en lugar de adivinar cuál debía ser: de motor de recomendaciones a detector de cambios.
• Agente de ventas y cobros. Cada tres horas comprueba que las operaciones ganadas en HubSpot llevan las cifras del presupuesto firmado, que cada operación cerrada tiene su factura y que las facturas vencidas tienen un plan de cobro documentado. No corrige datos: los deriva. Una corrección suya lo hizo más estricto: solo valida si cuadra el importe en moneda extranjera, porque si cuadra en dólares es que no se hizo la conversión.
• Agente de revisión de QuickBooks. Etiqueta cada asiento como normal, distinto o inesperado frente al periodo anterior. Él revisa los dos últimos grupos.
• Dos agentes analistas. Uno de desviaciones compara cada lunes lo real con el presupuesto (ARR neto nuevo, margen bruto, meses de caja, burn multiple, consumo de caja, plantilla, ingresos, contratación) según los umbrales de policy.yaml; otro, de análisis financiero, se ejecuta tras el cierre y redacta de cinco a diez observaciones numeradas, cada una con el cambio, una hipótesis y un siguiente paso.
• Agente de investigación. Surgió cuando se preguntó si el «¿por qué?» debía ser un segundo agente por encima del analista. Deriva cada aviso a un especialista con su propio guion. En su sexta ejecución, el especialista en circulante informó de que faltaban los datos de inventario y se detuvo en lugar de inventar.
• Agente controller (previsto en mayo de 2026), para derivar incidencias y hacer el seguimiento.

Paso a paso para replicar el patrón

1. Saca el mayor. Acceso por API de producción a QuickBooks Online o, si no puedes, exportaciones completas del libro mayor. Siempre hay una forma de llevar los datos a tu ordenador, aunque sea un CSV.
2. Cópialo a una base de datos propia, cada día y con todos los periodos, para que agentes e informes trabajen sobre una única fuente de verdad en lugar de llamar a cinco API.
3. Prepara las tablas de correspondencia en Excel primero. Puente entre planes de cuentas, agrupaciones, etiqueta de estado, departamentos y tipos de cambio.
4. Usa el modo plan. Pide a Claude Code un plan, léelo, corrígelo y después deja que construya.
5. Haz que todo cuadre. El resultado de cada sociedad debe coincidir con QuickBooks; las sociedades convertidas deben sumar el total consolidado; la tesorería del estado de flujos debe coincidir con la del balance. No dejes que Claude fuerce la diferencia de conversión para cuadrar.
6. Contrasta antes de fiarte. Ejecuta el script nuevo sobre los últimos doce meses frente a lo contabilizado, explica cada diferencia y mantén los dos métodos en paralelo durante varios cierres.
7. Deja la contabilización tras una persona. Pantalla de revisión, confirmación expresa y periodos cerrados bloqueados en QuickBooks.
8. Añade los agentes al final, con una tarea cada uno, que avisen de cambios e informen de los huecos en lugar de rellenarlos.

Cópialo y adáptalo

Altman no publica código, archivos de prompts ni repositorio; los prompts breves citados arriba proceden de sus artículos. Todo lo que sigue es una plantilla de Agents Finance basada en su descripción, pensada para una empresa en QuickBooks Online y una base de datos Postgres como Supabase. Nada se ha ejecutado contra una empresa real de QuickBooks: pruébalo antes en una empresa de pruebas (sandbox). Estos archivos no llevan secretos; las claves van en variables de entorno. El código es el mismo que en la versión inglesa; puedes escribir el prompt y el CLAUDE.md en español.

Requisitos previos

• QuickBooks Online con acceso de administrador y una cuenta de Intuit Developer. Las claves de producción exigen el cuestionario de evaluación de la app, también para apps privadas. Si un agente de IA te ayuda a rellenarlo, lee cada respuesta antes de enviarlo: eres tú quien declara cómo trata los datos la app.
• Claude Code con un plan de pago de Claude (no está en el plan gratuito).
• Una base de datos Postgres (Supabase u otra) y un sitio donde ejecutar una tarea diaria.
• Python 3.11 o superior con requests y psycopg para la plantilla de sincronización.
• Opcional: webhooks de entrada de Slack para los avisos de los agentes.

1. Prompt inicial para el primer cálculo (plantilla de Agents Finance)

Sustituye las variables entre llaves dobles. El script prepara el asiento, pero no lo contabiliza.

We are in plan mode. Do not write code until I approve the plan.

Goal: a script that produces our monthly revenue recognition journal entry for {{MONTH}}.

Inputs
- Billing export: {{BILLING_FILE_OR_API}} (one row per invoice line: customer, product line, amount, service period, discount %).
- Closed-won deals: {{CRM_EXPORT_OR_API}} (deal id, customer, line items, ship date).
- Last month's workbook, which shows the method I use today: {{LAST_MONTH_XLSX}}.

Method (deterministic, no estimates by the model)
- Software revenue is recognised ratably over the service period.
- Hardware revenue is recognised on {{INVOICE_DATE_OR_SHIP_DATE}}.
- Discounts reduce revenue on the same basis as the line they belong to.

Outputs
1. An Excel file with: revenue summary by customer and product line, the journal entry (account, debit, credit, memo), and a deferred revenue waterfall for the next 12 months.
2. A JSON file with the journal entry, ready to post. The script must NOT post anything.

Checks
- Total revenue in the entry = total in the summary = movement in deferred revenue + billings.
- List every billing line that could not be matched to a deal.

Then propose how to back-test this method against the last 12 months already booked in QuickBooks, month by month, and how you will show me differences down to the customer and line.

2. Esquema de base de datos para la copia diaria del mayor (plantilla de Agents Finance, Postgres)

Líneas del mayor, tablas de correspondencia y de tipos de cambio, resultado según QuickBooks y vista de cuentas sin asignar.

-- One row per general ledger line, per QuickBooks company
create table if not exists gl_line (
  entity        text        not null,   -- e.g. 'US', 'UK'
  txn_date      date        not null,
  txn_type      text,
  doc_num       text,
  account_name  text        not null,
  name          text,                   -- vendor / customer
  memo          text,
  debit         numeric(18,2) default 0,
  credit        numeric(18,2) default 0,
  currency      text        not null,
  synced_at     timestamptz not null default now()
);
create index if not exists gl_line_entity_date on gl_line (entity, txn_date);

-- Mapping tables, built in Excel first and loaded as CSV
create table if not exists coa_bridge (
  entity        text not null,
  account_name  text not null,
  group_name    text not null,           -- consolidated account / summary group
  statement     text not null check (statement in ('IS','BS')),
  primary key (entity, account_name)
);

create table if not exists fx_rate (
  month         date not null,           -- first day of month
  currency      text not null,
  avg_rate      numeric(18,8) not null,  -- for the P&L
  month_end_rate numeric(18,8) not null, -- for the balance sheet
  primary key (month, currency)
);

-- Net income per entity and month as reported by QuickBooks (loaded by the sync)
create table if not exists qbo_net_income (
  entity        text not null,
  month         date not null,
  net_income    numeric(18,2) not null,
  primary key (entity, month)
);

-- New accounts that nobody has mapped yet: show this on the dashboard
create or replace view unmapped_accounts as
select distinct g.entity, g.account_name
from gl_line g
left join coa_bridge b on b.entity = g.entity and b.account_name = g.account_name
where b.account_name is null;

3. Control de cuadre: nuestra cuenta de resultados frente a QuickBooks (plantilla de Agents Finance)

Cada fila que devuelva es una diferencia que hay que investigar antes de usar las cifras.

-- Any row returned is a break to investigate before anyone uses the numbers
with ours as (
  select g.entity,
         date_trunc('month', g.txn_date)::date as month,
         sum(g.credit - g.debit) as net_income
  from gl_line g
  join coa_bridge b on b.entity = g.entity and b.account_name = g.account_name
  where b.statement = 'IS'
  group by 1, 2
)
select coalesce(o.entity, q.entity) as entity,
       coalesce(o.month, q.month)   as month,
       o.net_income                 as ours,
       q.net_income                 as quickbooks,
       coalesce(o.net_income,0) - coalesce(q.net_income,0) as difference
from ours o
full join qbo_net_income q on q.entity = o.entity and q.month = o.month
where abs(coalesce(o.net_income,0) - coalesce(q.net_income,0)) > 0.01
order by 1, 2;

4. Sincronización diaria desde el informe General Ledger de QuickBooks (plantilla de Agents Finance, sin probar)

Lee el informe GeneralLedger mes a mes y sustituye ese mes en gl_line, revisando cada día los 24 meses anteriores. Imprime antes una respuesta y ajusta COLS a tus columnas.

"""Daily copy of the QuickBooks Online general ledger into Postgres.
Agents Finance template based on Alex Altman's description. Untested: run it
against a sandbox company first. Credentials come from environment variables."""
import os, datetime as dt, requests, psycopg

BASE = "https://quickbooks.api.intuit.com"          # sandbox: https://sandbox-quickbooks.api.intuit.com
REALM = os.environ["QBO_REALM_ID"]
TOKEN = os.environ["QBO_ACCESS_TOKEN"]               # refresh it with your OAuth flow before running
ENTITY = os.environ.get("ENTITY", "US")
CURRENCY = os.environ.get("CURRENCY", "USD")
COLS = "tx_date,txn_type,doc_num,name,memo,debt_amt,credit_amt"

def fetch(start, end):
    r = requests.get(f"{BASE}/v3/company/{REALM}/reports/GeneralLedger",
                     params={"start_date": start, "end_date": end, "columns": COLS},
                     headers={"Authorization": f"Bearer {TOKEN}", "Accept": "application/json"},
                     timeout=120)
    r.raise_for_status()
    return r.json()

def walk(rows, account=None):
    """The report nests one section per account; data rows sit inside."""
    for row in rows.get("Row", []):
        if "Header" in row:  # section header carries the account name
            acc = row["Header"]["ColData"][0].get("value") or account
            yield from walk(row.get("Rows", {}), acc)
        elif row.get("type") == "Data":
            yield account, [c.get("value", "") for c in row["ColData"]]

def num(x):
    try: return float(x)
    except ValueError: return 0.0

def sync_month(conn, first):
    last = (first.replace(day=28) + dt.timedelta(days=4)).replace(day=1) - dt.timedelta(days=1)
    rep = fetch(first.isoformat(), last.isoformat())
    lines = [(acc, v) for acc, v in walk(rep.get("Rows", {})) if v and v[0] and v[0][0].isdigit()]
    with conn.cursor() as cur:
        cur.execute("delete from gl_line where entity=%s and txn_date between %s and %s", (ENTITY, first, last))
        for acc, v in lines:
            cur.execute("""insert into gl_line (entity, txn_date, txn_type, doc_num, name, memo,
                           account_name, debit, credit, currency)
                           values (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)""",
                        (ENTITY, v[0], v[1], v[2], v[3], v[4], acc, num(v[5]), num(v[6]), CURRENCY))
    conn.commit()
    return len(lines)

if __name__ == "__main__":
    months_back = int(os.environ.get("MONTHS_BACK", "24"))   # re-check prior periods every day
    today = dt.date.today()
    with psycopg.connect(os.environ["DATABASE_URL"]) as conn:
        for i in range(months_back):
            y, mth = divmod(today.year * 12 + today.month - 1 - i, 12)
            first = dt.date(y, mth + 1, 1)
            print(first, sync_month(conn, first))

5. CLAUDE.md del agente de proveedores (plantilla de Agents Finance)

Contrato archivado, cambio de cuenta frente a la última factura e importe anómalo; nunca edita, aprueba, paga ni contabiliza.

# AP review agent

## Job
Review every new bill and card expense since the last run and tell the head of finance
what passed and what needs attention. You never edit, approve, pay or post anything.

## Sources (read-only)
- Database tables: gl_line, bills, card_expenses, vendors.
- Contracts folder: {{DRIVE_CONTRACTS_FOLDER}} (one subfolder per vendor).

## Checks, in this order
1. Contract on file: if the vendor has no contract in the folder, flag "no contract".
2. Account change: compare the GL account with the account used on this vendor's previous bill.
   If it differs, flag "different account than last bill" and say whether the change looks
   reasonable. Do NOT guess what the right account should be.
3. Amount outlier: flag if the amount is more than {{OUTLIER_PCT}}% above the vendor's
   average of the last {{N_BILLS}} bills, or if it is the first bill above {{NEW_VENDOR_LIMIT}}.

## Output (one Slack message per run)
- Line 1: counts (reviewed / passed / flagged).
- Then one bullet per flag: vendor, date, amount, account, check that failed, your recommendation.
- If a source is missing or a query fails, say which one and stop. Never fill gaps with assumptions.

6. Umbrales del agente de desviaciones (plantilla de Agents Finance)

Cifras de ejemplo: ajústalas a tu empresa.

# policy.yaml — read by the variance agent every Monday; change thresholds here, not in prompts
compare_to: plan            # plan | prior_month | prior_year
metrics:
  net_new_arr:      { flag_if_variance_pct_over: 10 }
  gross_margin_pct: { flag_if_points_below_plan: 2 }
  runway_months:    { flag_if_drop_week_over_week: 1 }
  burn_multiple:    { flag_if_above: 2.0 }
  cash_burn:        { flag_if_variance_pct_over: 15 }
  headcount:        { flag_if_behind_plan_by: 2 }
  revenue:          { flag_if_variance_pct_over: 5 }
  bookings:         { flag_if_variance_pct_over: 15 }
opex_lines:
  flag_if_variance_abs_over: 10000   # in reporting currency
collections:
  flag_if_qtd_behind_plan_pct: 10
output:
  channel: "#finance-flags"
  max_items: 10
  each_item_needs: [metric, actual, plan, variance, drill_through_query]

7. Exploración de solo lectura con el servidor MCP de Intuit (extracto literal, Apache-2.0)

Si quieres que Claude Code responda preguntas sobre la contabilidad antes de construir ningún script, Intuit publica un servidor MCP local cuya configuración permite desactivar las categorías de herramientas que escriben. Extracto del README de intuit/quickbooks-online-mcp-server (licencia Apache 2.0 en su archivo LICENSE, aunque la insignia del README dice MIT). Solo hemos cambiado los tres valores DISABLE_* a "true"; no es la vía que usó Altman, que llamó directamente a la API.

{
  "mcpServers": {
    "quickbooks": {
      "command": "node",
      "args": ["path/to/mcp-quickbooks-online/dist/index.js"],
      "env": {
        "QUICKBOOKS_CLIENT_ID": "your_client_id",
        "QUICKBOOKS_CLIENT_SECRET": "your_client_secret",
        "QUICKBOOKS_REFRESH_TOKEN": "your_refresh_token",
        "QUICKBOOKS_REALM_ID": "your_realm_id",
        "QUICKBOOKS_ENVIRONMENT": "sandbox",
        "QUICKBOOKS_DISABLE_WRITE": "true",
        "QUICKBOOKS_DISABLE_UPDATE": "true",
        "QUICKBOOKS_DISABLE_DELETE": "true"
      }
    }
  }
}

Un ejemplo concreto (ficticio)

Una empresa tiene una sociedad en Estados Unidos y otra en Reino Unido en QuickBooks. La consulta de cuadre devuelve una fila: el resultado de marzo de la sociedad británica difiere 1.200 libras del de QuickBooks. La vista unmapped_accounts lo explica: en marzo se creó la cuenta «Software subscriptions – EMEA» y no está en coa_bridge. El controller la asigna, la diferencia desaparece y la cuenta de resultados consolidada de marzo cuadra. El martes, el agente de proveedores publica: 14 facturas revisadas, 12 correctas y 2 marcadas: un proveedor de nube contabilizado en «Honorarios profesionales» en lugar de en «Alojamiento», como el mes anterior, y un colaborador nuevo sin contrato en la carpeta. No se contabiliza nada hasta que decide una persona.

Resultados declarados por la fuente

Todas las cifras son de Alex Altman, sobre su propio trabajo, y no están auditadas:

• El reconocimiento de ingresos llevaba cuatro horas al mes según el artículo de marzo y de cuatro a seis según la sesión en directo; ahora es «un clic o tres», después de varios meses con los dos métodos en paralelo.
• En el contraste con doce meses, Claude Code trabajó unos 45 minutos y encontró en junio una diferencia que era un error de la contabilidad (una línea de una operación que se cerró tarde pero se envió ese mes). Se registró, con su aprobación, un asiento de corrección en el mes abierto.
• Rehacer la consolidación le llevó unas tres horas, con la conexión a QuickBooks ya hecha; la copia diaria tiene unas 60.000 líneas del mayor.
• En sus primeras ejecuciones, el agente de proveedores encontró un proveedor habitual sin contrato archivado y el de ventas, cuatro operaciones cerradas cuyas líneas no se habían trasladado, antes del cierre trimestral.
• Gastó unos siete millones de tokens el mes en que construyó la mayor parte del portal.

Limitaciones y riesgos

• Un solo narrador. Artículos y sesión vienen de la misma persona; no hay declaración de los auditores ni del contable de Coram AI, ni una duración del cierre o una tasa de errores medidas.
• El acceso de escritura es real. Altman avisa de que, una vez conectado, Claude Code puede contabilizar, editar y reclasificar en bloque; los periodos cerrados de QuickBooks son el único freno firme. Su consejo a quien no programa de «decir que sí» a las preguntas que no entiende vale para construir, no para contabilizar: lee cada petición de escritura.
• Las respuestas del cuestionario son tuyas. Dejar que un agente rellene la evaluación de Intuit es rápido, pero las respuestas describen tu seguridad y tu tratamiento de datos y tienen que ser ciertas.
• La copia de datos es un sitio más que proteger: accesos, copias de seguridad y quién ve qué.
• Dependencia de una persona. Documenta los scripts y controles para que el contable o un auditor puedan seguirlos.
• El inventario no está resuelto. En la sesión reconoció que su módulo de inventario seguía fallando; los agentes se presentan como trabajo en curso, con el agente controller todavía previsto en mayo de 2026.

Errores frecuentes

• Pedir a Claude las cifras en lugar del script que las calcula.
• Saltarse el modo plan y aceptar lo primero que construye.
• Montar una consolidación sin vista de cuentas sin asignar, de modo que las cuentas nuevas desaparecen sin avisar.
• Forzar la diferencia de conversión para que el balance cuadre siempre, lo que esconde los errores.
• Un agente para todo. Altman comprobó que una tarea por agente, con su propio CLAUDE.md, daba prompts más claros y mejores resultados.
• No ajustar los umbrales: demasiados avisos son ruido.

Conclusiones

El caso de Coram AI trata menos de un agente ingenioso que de un orden: sacar el mayor, hacer que las cifras sean deterministas y cuadren con QuickBooks, dejar la contabilización en manos de una persona y solo entonces poner agentes a vigilar los cambios. Para una empresa en QuickBooks Online que ha superado las hojas de cálculo, es un camino creíble que un responsable financiero puede empezar solo, si los controles crecen al ritmo de las herramientas.