Everything it does, and everything it does not

Double entry the database enforces, and the two transaction cycles on top of it.

• Automated general ledger

  Built

  Debits equal credits at commit, enforced by a deferred constraint trigger rather than by the code that writes the entry. A posted journal never changes; a correction is a reversal that both stay readable.

• Accounts payable

  Built

  Requisition, purchase order, goods receipt, supplier invoice, three-way match, payment. A variance has to be explained before anybody can approve past it.

• Accounts receivable

  Built

  Customer invoice, issue, cash receipt, application and ageing, with receipts reaching the ledger rather than only settling the invoice.

• Fiscal calendar and periods

  Built

  A state machine per period, where closing requires an authority that preparing does not.

• Gap-free document numbering

  Built

  Dense per series, claimed inside the writing transaction, so a rolled-back document returns its number. A gap is a question an auditor asks and nobody can answer.

• Exact money arithmetic

  Built

  Decimal strings and scaled integer arithmetic. No float touches a figure anywhere, because a limit is exactly the place that difference decides an outcome.

• Real-time trial balance

  Built

  Computed from lines rather than maintained as a stored number, so it cannot drift from the entries that produced it.

What a controller at a multi-entity group is actually buying.

• Multi-entity consolidation

  Built

  Intercompany balances found by identity rather than by naming convention, effective interest multiplied down the ownership chain, non-controlling interest separated, and every elimination shown pair by pair.

• Multi-currency

  Built

  Every line carries what the transaction was in and what it is worth in the entity's functional currency. Spot, average and closing rates do different jobs, and only monetary items revalue.

• Bank reconciliation

  Built

  A continuously re-runnable invariant rather than a monthly task. The matcher declines rather than guesses, and what it could not match stays visible as exposure.

• Close management

  Built

  A health score denominated in performance materiality, decomposable into the named breaches that produced it, with the domains that cannot be scored named rather than counted as passing.

• Completeness

  Built

  The query for the invoice that was never created. Expected events are stored as hypotheses before they fail to arrive, because absence has no row to select.

• Exception queue

  Built

  A closed vocabulary of dispositions, and the person who raised an exception cannot be the person who closes it.

• Drill to evidence

  Built

  One primitive on every surface. Any figure descends to the record that produced it, and a record with nothing beneath it says why rather than dead-ending.

• Enterprise search

  Built

  Vector and lexical, fused by rank, and authorized exactly like every screen. What somebody can find is what they could have clicked to.

Agents hold identities, roles, limits and duty constraints in the same tables as people and are evaluated by the same engine. There is no agent bypass path.

• Agents as governed principals

  Built

  Same tables, same authorization engine, same access review, same duty conflicts. An agent has a charter, a value ceiling and a named human owner, and an agent nobody is accountable for is refused.

• No agent approves anything

  Built

  The engine refuses an approval capability to a non-human principal before it consults their grants, so a misconfigured role cannot produce a machine approval. Absolute, at every autonomy level.

• Trust envelope

  Built

  Per action, not per setting. An agent's autonomy level, value ceiling and measured track record decide whether a proposal commits and notifies, waits for one approver, waits for two, escalates, or is refused. There is no silent commit in the vocabulary.

• Two-person autonomy changes

  Built

  Widening a machine's envelope takes one person asking and a different person agreeing, refused in three places. Narrowing takes one, because taking authority away from a machine is never the dangerous direction.

• Agent health

  Built

  An agent humans keep overriding narrows itself, with nobody turning a knob. Shown beside the ceiling it narrows, naming the component that is dragging it rather than pronouncing a band.

• Approver control health

  Built

  Whether the approval control is operating, not whether it exists. Time spent, evidence opened, whether they ever disagreed, and whether a queue was cleared in bursts. A zero rejection rate is investigated, not celebrated.

One operational event, ingested, contextualised, decided, governed and posted. Two of its eight stages happen today. This is what version 1.0 means.

• Accounting policy in the posting path

  Built

  Policy as versioned, tested, executable code, consulted by the posting rather than answering when asked. A supplier invoice is determined at entry by the policy in force on the invoice's own date, and an imported service posts as a reverse charge: four entries rather than two, with the tax not folded into the expense. Booked the other way it balances and is wrong.

• The Constitution on every event class

  Partly wired

  Payments, receipts and manual journals determined the same way a supplier invoice and a customer invoice now are.

  Today: Two of five event classes. The other three receive the subledger default without consulting the policy in force.

• Advanced revenue recognition

  Partly wired

  Contracts and performance obligations, with standalone selling prices that record whether they were observed or estimated. A subscription billed annually in advance defers to a contract liability rather than recognising revenue on issue, because billing is not earning and both treatments balance. The deferral then releases period by period as the obligations are satisfied, and running it twice releases nothing twice.

  Today: The deferral releases as obligations are satisfied, and a person runs it rather than a clock, because there is no scheduler and a posting nobody authorised is not something this product does. An obligation satisfied at a point in time still releases with the first period rather than when somebody says it was delivered. Contract authoring has no screen, and products, price books, subscriptions and contract modifications are not built.

• Trust envelope on every producer

  Partly wired

  Every machine proposal passing through its envelope before a person sees it.

  Today: Two of five determination producers are wired to it. The other three reach a human without passing through the envelope.

• Event ingestion

  Not built

  Normalised, deduplicated, source-attributed, immutable canonical business events.

  Today: There is no event log table. Work enters the system as somebody filling in a form, and the deduplication that exists is at the write rather than at an ingestion boundary.

• Native integrations

  Not built

  Bank feeds, billing, payroll and CRM, arriving as events.

  Today: No connector of any kind is built. A bank statement is pasted in as CSV.

• Document store

  Not built

  The scanned invoice behind the record, as part of its context and its lineage.

  Today: Lineage terminates at the point where a document would be, and says so.

• Scheduling

  Not built

  Assurance, reconciliation and forecasting running without a person starting them.

  Today: Every agent run is a person pressing a button, so continuous means re-runnable rather than running.

• Agent memory

  Partly wired

  An agent reading what it concluded last time before concluding again. Today it means one thing specifically: an agent does not raise a finding somebody has already ruled on, and it says how many it suppressed. That is what stops an exception queue becoming a list people have learned to skip.

  Today: Two of the producers that have a subject a person rules on. A dismissal is permanent for that subject with no expiry, and nothing else reads a prior run.

• Machine-to-machine API access

  Not built

  A credential an integration can hold, with rotation and its own audit treatment.

  Today: The API is versioned and goes through one boundary, and it authenticates by session cookie only. It is an internal API rather than a public one.

Deferred deliberately. Each one changes the shape of the ledger, and doing them before the flows were proven would have been rework.

• Bitemporality

  Not built

  What the books said on a date, given what was known then. Two time axes on every fact, not one.

  Today: A journal carries a posting date and a wall clock, which answers when it was recorded and not what was known at the time.

• Multi-book reporting

  Not built

  One fact projected into every basis that has to see it, rather than a second set of entries.

  Today: There is one book. An entity's accounting standard is a label rather than a parallel set of books.

• Policy replay

  Not built

  Re-deriving the ledger under a different policy version, standard, or point in time.

  Today: Not possible without the event log, which is a phase five capability.

• Financial knowledge graph

  Not built

  Entities, contracts, counterparties and obligations as a traversable graph.

  Today: Lineage is a typed traversal over foreign keys, which answers where a figure came from and not what else is connected to it.

• Financial digital twin

  Not built

  A simulated copy of the business, for asking what would happen if.

• Precedent retrieval

  Not built

  Finding how a materially similar question was decided before, and citing it.

  Today: Retrieval exists over past coded invoice lines. Retrieval over past determinations, which is the stage the design calls for, does not.

• Interpretation, where a rule cannot decide

  Not built

  A model consulted only where the deterministic solver has no answer, with its output governed exactly like any other determination.

  Today: No language model is called anywhere in this product. Every determination is a rule, a statistic or a retrieval, and natural language is answered by a grammar that never generates SQL.