A private Reasoning Engine works over your trust accounting, fee, and governing-document data — inside your boundary. It produces answers your team can act on, and shows its work rather than asserting a result. You adopt Reasoning Engine blocks under your own governance, one block at a time — nothing replaced until the parallel run proves it.
The trust department runs on two kinds of decisions — judgment and arithmetic. Both need to be defensible.
Where judgment lives. The Reasoning Engine reads the governing instrument, supports discretionary distribution decisions with documented rationale, prepares annual administrative reviews, and surfaces the accounts that need an officer's attention — showing its reasoning rather than asserting a result.
Built on Agent Studio and Natural Language Interface.
Where arithmetic lives. Reasoning Engine blocks verify fee calculations, reconcile principal and income, tie out tax lots, and surface exceptions before they reach a statement — against your firm's own definitions, not a vendor's.
Built on the Foundation Blocks catalog and Ontology Builder.
Every trust department eventually faces one question: can you prove what you decided, and when?
Litigators already know the answer. In discovery, every produced document carries a digital fingerprint — a hash — so the court can confirm nothing changed between collection and the courtroom. Federal evidence rules accept a matching fingerprint as proof in itself. No witness required.
r.Team applies that same proof to every fiduciary event — a document received, an interpretation applied, a statement issued, a distribution approved or denied. Each fingerprint is built from the one before it; change anything, and the break shows. On a schedule, the fingerprints are published to a public record neither we nor you control — because a record we control proves nothing. Your documents never leave your environment.
Five years from now, when a beneficiary's counsel asks whether a statement was altered, nobody has to be believed. It can simply be checked.
That proof can't be reconstructed after the question is asked. The record has to be running first.
Each fiduciary event is written to a canonical record and hashed. Every hash incorporates the previous hash for that account, forming a per-account chain in which no earlier entry can be altered without invalidating everything after it.
On a fixed schedule, hashes from across the platform are gathered into a single Merkle tree and only the root — 32 bytes — is published to the Bitcoin blockchain. We chose Bitcoin for its neutrality rather than its features: it has done one job since 2009, and no one credibly argues about who controls it.
Verification is arithmetic, not trust. Re-hash the document, walk its inclusion proof up the tree, and confirm you arrive at the root recorded in that block.
Three things worth stating plainly: no cryptocurrency changes hands in the client relationship; no client data touches the public record; only a fingerprint is published.
For decades, software was an empty vessel. It executed logic, but the intelligence lived outside it — a programmer had to anticipate every question, and an advisor, operator, or client had to supply every answer. Every workflow was really a conversation between people, with software merely passing messages between them.
That architecture is obsolete. AI-native software carries both sides of the conversation within itself. It knows what to ask because it understands the domain, and it can answer because it reasons over your data directly. The question and the answer no longer live in two different heads — they coexist inside the system.
This is the first principle r.Team is built on: design for intelligence in the core, not for a human patching the gaps. Every Reasoning Engine block and agent carries its own questions and its own answers — which is exactly what makes each one independently useful, and what makes them compose. You set the intent, the standards, and the boundaries. The system does the asking, the answering, and the acting — inside them.
Frontier intelligence, harnessed — not bolted on.
Composable AI
Build your intelligence stack the way you build a portfolio — piece by piece, swappable, yours. A library of AI modules you connect to the systems you already run.
Frontier-class models running privately for your firm. Your data never trains someone else's model. Each block exposes a clean interface so it can be swapped or upgraded without touching anything downstream.
Explore the Reasoning Engine →Task-focused agents packaged as independent units: research, drafting, reconciliation, monitoring. Each agent does one job well and hands off cleanly to the next through defined interfaces.
Explore Agent Studio →Blocks and agents wake on events — a custodian file lands, a client record changes, a threshold trips — run their job, and go quiet. No polling, no batch windows, no babysitting.
When your platform is licensed, the definitions of your own business live in someone else's system: what an account is, how a fee computes, which conventions govern a distribution, what an annual review must contain. Your people know these things — but the system of record for that knowledge renews annually, priced by someone else.
Ownership inverts this — not of the software, but of what matters more. Your procedures, your documentation, and your data live in an ontology that belongs to your institution: a portable asset you hold, independent of any license line. The Reasoning Engine — our software, maintained and advanced by us — works over your ontology inside your boundary, on a metered substrate that costs a fraction of legacy licensing. If the relationship ever ends, the software goes home with us. Your definitions stay with you, in a form you can read, audit, and take anywhere.
The economics follow the architecture. What you stop spending on renewals, you can spend on people — paying your associates for their intelligence instead of paying to rent your own.
Rent the engine. Own the knowledge.
The intelligence stack
Three layers — the same pattern used to turn operational noise into mission-ready decisions, applied to trust operations signals and fiduciary governance.
Connect custodians, CRM, trust accounting, and reporting into a unified ontology — accounts, entities, fees, beneficiaries, and conventions your operators already trust.
The Reasoning Engine queries and analyzes that connected data — surfacing exceptions, concentrations, and variances before they reach a client statement.
Agent Studio executes governed workflows on events — overnight reconciliation, fee monitoring, exception surveillance — with full audit trails and human-in-the-loop approvals.
Explore the product blocks that implement each layer. View products →
Trust accounting core
Every engagement starts from proven foundation blocks that implement the conventions legacy platforms took decades to accumulate — so the parallel run reconciles against real fiduciary behavior, not a prototype.
Lock a statement cycle's data at cut-off so reprints, audits, and regulator requests reproduce exactly what the client received.
Interest and dividend accruals with day-count and convention parity, plus as-of transaction processing that correctly restates affected balances, accruals, and fees.
Custodial feed ingestion, position and cash reconciliation against the custodian, and corporate-action processing.
Tiered schedules, prorations, minimums, and split fees, reconciled to the penny against the legacy fee cycle.
Dual cash-bucket tracking for fiduciary accounts, with income sweeps and distributions.
Lot-level cost basis with configurable relief order and full disposition history.
Multi-source pricing with fallback rules and stale-price handling, matched to the legacy hierarchy during validation.
Corporate actions are where trust accounting errors compound. r.Team treats every announcement as a governed event: captured, interpreted, calculated, and posted with a full reasoning trail.
Statement-level totals with rounding parity, plus examiner- and audit-ready output.
Reads trust instruments and proposes governing terms for human review — cited, versioned, and approved before anything reaches the system of record.
Every foundation block carries its own parity specification — the documented legacy behavior it matches, and the signed decisions where it deliberately improves on it. How validation works →
Ontology Builder supplies the definitions. The Knowledge Graph supplies the relationships. Agent Studio supplies the actions. The Reasoning Engine is the intelligence that combines them — answering questions, applying fiduciary rules, and driving decisions over trust accounting data for trust companies, RIAs, family offices, and bank trust departments.
Explore the Reasoning Engine → Read the vocabulary definition → Reasoning Engine FAQ →
Plain answers about the Reasoning Engine, modernization, and ontologies for fiduciary operations.
A Reasoning Engine for trust operations is private AI that works over your connected trust data — accounts, fees, beneficiaries, and governing rules — to answer questions and support fiduciary decisions while showing its work for human review.
Adopt composable blocks under a Parallel-Run Method: run new intelligence alongside the legacy platform, reconcile nightly to zero, and cut over only when validated — without forcing a multi-year rip-and-replace.
An ontology is a portable model of what your firm means by accounts, entities, fiduciary roles, fee schedules, and beneficiaries — so systems and AI share one vendor-neutral source of truth.
Trust companies, RIAs, multi-family offices, and bank wealth & trust departments that need governed AI for trust administration, trust operations, and fiduciary work — not generic chatbots.
Got-Data Inc. is the company behind r.Team. The brand ships composable intelligence blocks for trust administration and operations; the legal entity is Got-Data Inc.
Request a focused demo — tailored to your platform, use cases, and governance requirements.
Request a demo