UI-first data model
Traditional accounting software assumes a bookkeeper logs in, tabs through fields, and hits save. Every schema decision, every validation, every default was written for a human at a screen. Agents don’t work that way.
Now Available · Open Tooling · Module 03
The Ledger Built for AI Agents, Not Humans.
Local-first, double-entry accounting. 15 MCP tools. SQLite backend. Immutable transactions. Audit log inside the same DB transaction as every write. Zero vendor lock-in. $0 to run forever.
How much cash do we have right now?
Used openledger integrationYou have $49,900 in cash right now, across:
- Cash $4,300
- Bank $37,600
- Wallet A $4,750
- Wallet B $3,250
(Accounts Receivable of $0 isn’t included since it’s money owed, not cash on hand.)
How much cash do we have right now? Write a message…
- 15
- MCP Tools
- 4
- Core Invariants
- $0
- Forever
- Apache 2.0
- License
The problem
Accounting SaaS was built for humans typing entries into forms.
AI agents are a different kind of user. When they post a $50,000 transaction into QuickBooks or NetSuite, the systems on the other side of that API were never designed to produce the evidence an auditor will demand.
Per-seat pricing that penalizes automation
The more workflows you automate, the more agents you deploy, the faster your bill grows. Legacy accounting SaaS was priced on the assumption that fewer people would touch the books — the opposite of the agent era.
Your books live on their servers
Your general ledger, chart of accounts, and full transaction history sit inside a vendor’s cloud, subject to their pricing, their SLAs, their subpoena posture. Data residency is a checkbox in a contract, not a property of the software.
Audit trails that live outside the write
The mutation happens in the ledger. The audit log happens somewhere else — Datadog, Splunk, a Postgres table nobody reads. When the write succeeds and the log fails, or vice versa, nobody knows. That’s not an audit trail. That’s a wall of log lines.
Built differently
Built from the ground up for agents as the primary operator.
Not an accounting app with an MCP wrapper. An evidence-first ledger with a clean interface for every client that needs it — agents, humans, and the audit team who reviews both.
Intentionally Headless
No frontend ships with OpenLedger. The ledger and its MCP tools are the product. Build the UI you want, or skip it entirely and operate the books through Claude Desktop.
Immutable by Design
Transactions and entry lines are never updated or deleted. Corrections happen via contra posting — the original stays, tagged reversed. Your entire history is intact and legally defensible.
Real Double-Entry
Every transaction has ≥ 2 entry lines. Debits equal credits — enforced in the write path, in one SQL transaction. Unbalanced entries are physically impossible in the schema.
Local-First & Self-Hosted
SQLite-backed with zero cloud dependencies. Run it on your laptop, a $5 VPS, or inside your VPC. Nothing crosses a boundary you didn’t approve.
MCP-Native
15 tools built for Claude Desktop, Claude Code, Cursor, and any MCP-compatible client. Ask the model in plain English — the ledger answers with real numbers from real books.
Integer Cents. No Floats.
Every amount is stored as an integer minor unit. Zero floating-point rounding bugs. The category of “our reconciliation is off by a penny for reasons no one can trace” is architecturally eliminated.
Apache 2.0 Licensed
Enterprise-legal-friendly. Commercial embedding is fine. No copyleft trap. No enterprise-tier gates. No per-seat surprises. You own it. You run it. You fork it.
$0 Forever
- Commercial use
- Modification
- Distribution
- Patent grant
- Private use
- Sublicense
The four invariants
Every number has proof.
Traditional ledgers rely on process to enforce correctness — checklists, review workflows, month-end reconciliations. OpenLedger enforces the invariants in the schema and the write path itself. If it can’t be true in the database, it can’t happen in the ledger.
Real double-entry, at the write path
Every transaction must have ≥ 2 entry lines. sum(debits) = sum(credits). Enforced inside a single database transaction — if the balance check fails, the whole insert rolls back. Unbalanced entries are physically impossible.
Integer minor units. No floats.
Every amount is stored as an integer cents value. There is no float anywhere in the amount math. The class of bug where 1.005 * 100 == 100.4999999 is architecturally eliminated. Your reconciliations will never be off by a penny for a reason nobody can trace.
Immutability. Corrections via contra posting.
Transactions and entry lines are never UPDATE-d or DELETE-d. Corrections happen via reverse_transaction() — a contra entry that posts alongside the original. Both stay in the ledger. Every historical state is reconstructable.
Audit log in the same DB transaction as the write
Every mutation writes an audit_log row inside the same SQL transaction as the mutation itself. Either both commit or both roll back. It is not possible for a write to succeed without its audit trail — this is the SOX-grade guarantee closed accounting SaaS won’t give you.
Why this matters when agents are writing to your books
Most accounting systems treat the audit trail as a sidecar. The mutation happens in the ledger. The log happens somewhere else — Datadog, Splunk, a Postgres table. If the mutation succeeds and the log fails — or vice versa — nobody knows. When an auditor drills in, the story falls apart at the join between the two systems.
OpenLedger collapses that gap. The audit-log write lives inside the same SQL transaction as the mutation. The database itself enforces that either both happen or neither does. There is no state of the world where a write occurred but the trail didn’t.
That single property is the difference between passing an SSAE 18 audit and failing one. It is what your finance team’s audit partner is actually asking for when they ask “prove what the agent did.”
Read the full architecture →MCP-native
Claude understands your books natively.
15 MCP tools, drop-in for Claude Desktop, Claude Code, Cursor, and any MCP-compatible client. No plugin config. No schema translation. Ask the model a question about your books; it calls the tools and reports back.
- 15
- MCP Tools
- 1
- SELECT Escape Hatch
Accounts
5- list_accounts
- get_account
- get_balance
- get_account_ledger
- create_account
Journal
5- get_transaction
- search_transactions
- post_transaction
- transfer_funds
- reverse_transaction
Reports
3- get_trial_balance
- get_profit_loss
- get_balance_sheet
Audit
1- get_audit_log
Escape hatch
1- run_query
Example prompts
- How much cash do we have right now?
- Show me the P&L for January.
- Are the books balanced?
- Post a $250 cash sale for today.
Get started
Four commands. Running in minutes.
No Kubernetes. No paid tier. No enterprise sales call.
Clone the repo. Bootstrap the DB. Start the MCP server. Connect Claude. Total elapsed time from git clone to your first “how much cash do we have?” question: under ten minutes.
1
Clone the repo
Publicgit clone github.com/Attri-Inc/open-ledger.gitCloning into 'open-ledger'...remote: Enumerating objects: 341, done.✓ Cloned in 2.1s- Repo
- Attri-Inc/open-ledger
- Branch
- main
- License
- Apache 2.0
2
Install & bootstrap
Readycd open-ledger && python3 -m venv .venvpip install -r requirements.txtpython scripts/seed.py✓ Database initialized✓ Sample chart of accounts loaded- DB
- SQLite
- Runtime
- Python 3.11+
- Deps
- aiosqlite, mcp
3
Start the MCP server
Runningpython run_mcp.py✓ MCP server started (stdio)✓ 15 tools registered✓ Ledger ready at ./data/openledger.db- Transport
- stdio / SSE
- Tools
- 15 registered
- Port (SSE)
- :8791
4
Connect Claude
Connected# For Claude Code — one command:claude mcp add openledger -s user -- \ /abs/path/.venv/bin/python /abs/path/run_mcp.py✓ openledger MCP server registered- Client
- Desktop / Code / Cursor
- Setup
- < 60 seconds
- Auth
- Local
Comparison
OpenLedger vs. traditional accounting SaaS
Not a fair fight on cost. A different fight on architecture. Traditional accounting SaaS was designed for a human clicking through a UI, priced per seat, hosted on the vendor’s servers. OpenLedger flips every one of those assumptions.
| Property | Traditional Accounting SaaS | OpenLedger |
|---|---|---|
| Pricing model | $30–$200 / user / month, per module | $0 forever, self-hosted |
| Primary user | Human bookkeepers using a UI | AI agents via MCP + SQL |
| MCP support | None (or via a paid third-party plugin) | 15 tools, native, day one |
| Data ownership | Vendor servers, their export terms | Your infrastructure, your SQL |
| Audit trail | Sidecar log, sometimes eventually consistent | Same DB transaction as the mutation. Atomic. |
| Amount storage | Float or Decimal (usually with quiet rounding) | Integer minor units. Zero float bugs. |
| Corrections | UPDATE / DELETE on posted entries | Contra posting. Nothing is ever mutated. |
| Deployment | Cloud-only, vendor-managed | Laptop, VPS, VPC, air-gapped — you pick. |
| License | Proprietary, per-seat, per-module | Apache 2.0. Fork, embed, ship. |
The Open Tooling family
OpenLedger is one of three.
Open Tooling is an open-source family of AI-native infrastructure — the same headless, evidence-first, agent-first architecture applied across the enterprise systems of record that AI agents are becoming the primary writer for.
Shipping Customer memory
OpenCRM
Evidence-first CRM. 29 REST endpoints. 27 MCP tools. Artifacts → Observations → Briefs → Conflicts. In production with construction and AEC teams.
Shipping Agent observability
OpenWatch
Agent audit + governance. Ingests Anthropic’s Compliance API and local Cowork sessions into one governed store. Deployed with regulated firms running Claude at scale.
Now live Money
OpenLedger
Local-first double-entry ledger. 15 MCP tools. SQLite backend. Immutable, atomic-audit-log, integer-cents. The substrate every AI agent touching money should write to.
More modules in exploration: OpenDesk (incident management) · OpenComply (GRC + audit) · OpenAgent (agent identity). Same architecture. Different domain. All Apache 2.0.
Your agents deservebetter infrastructure.
Free to run. Open to fork. Ready for the finance workflows you’re building today.
- $0 forever
- Apache 2.0
- Self-hosted
- Local-first