Fabric - For CTOs & Engineers

The system of context
for financial AI.

Fabric is the most reliable way to build AI agents on your finance data - because we don't just send data to the model. We send meaning. Every transaction reconciled, encoded with e-commerce financial logic, and exposed in formats your agents natively consume.

Book a demo → See integrations
How Fabric works
1
Ingest
Every channel connected - Shopify, Amazon, Stripe, NetSuite, PayPal, TikTok, Global-e, 1k+ more. No ETL for you to build or maintain.
2
Reconcile
Every transaction matched, cleared, and verified at the ledger level. Clean by construction - not by hope.
3
Contextualize
We don't give you rows. We give you meaning. Every data point wrapped in accounting semantics: GAAP-compliant treatment, e-commerce financial logic, and a complete audit trail - based on our proprietary e-commerce edge-case repository.
4
Expose
Structured APIs. Warehouse-native sync (Snowflake, BigQuery, Databricks). An MCP server your LLMs can query directly.
✓ Your agents inherit context - not data they have to figure out
Why it works

The bottleneck isn't the model.
It's the data underneath it.

Most financial AI deployments fail for the same reason: the model is asked to compensate for incomplete, unreconciled inputs. Fabric does the hard work upstream - so your agents reason over truth, not noise.

Foundation

Reconciliation
before reasoning.

When you point an AI agent at a fragmented finance stack, you don't get insights - you get hallucinations. Confident-sounding answers that can't reconcile back to the books. Fabric clears every transaction before it touches an agent. Agents inherit certainty, not ambiguity they have to paper over.

Every transaction matched at the ledger level before any agent sees it
Matching runs on our compute - not yours, not the LLM's
Typically 90%+ of transactions never enter an LLM context window - cutting cost and latency dramatically
No hallucinations - agents reason over GAAP-compliant reconciled data, not raw logs
Without Fabric vs. with Fabric
❌ Without Fabric
Raw payout data → LLM
Orders don't match deposits. Fees missing. Agent infers, approximates, hallucinates.
✓ With Fabric
Reconciled financial graph → LLM
Every transaction cleared. Every fee explained. Agent reasons over ground truth.
✓ In finance, wrong answers aren't a demo problem - they're a compliance problem
The difference

Semantic context,
not raw exports.

Agents don't query a database - they traverse a financial graph. The difference is that a graph carries meaning: what a transaction is, where it came from, how it relates to the ledger, what accounting treatment it requires. Returns know they're returns. Fees know which channel generated them. Timing deltas are explained, not ignored.

GAAP-compliant treatment, ASC 606, e-commerce business logic - already encoded
Returns logic, fee waterfalls, gift card treatment - your agent doesn't have to learn your business
Every data point wrapped in context - not just what it is, but what it means
Financial graph - transaction context
Transaction · Order #SO-48821
$284.00 order total · Shopify · Nov 14
↓
Accounting treatment
ASC 606 · $263.50 merchandise → deferred at order (Nov 14), recognized on shipment (Nov 16) · $20.50 sales tax → liability, not revenue
↓
Payout linkage
Stripe payout Nov 19 · $275.46 net (fee $8.54 · 2.9% + $0.30) · fee booked as processing expense
↓
Agent context ready
Matched to payout & bank deposit · GAAP-compliant journal entry · posted as JE-2291
Exposure layer

Works with Claude
natively.

An MCP server means Claude - and any other LLM - can discover and query your reconciled financial data with zero custom plumbing. Warehouse-native sync to Snowflake, BigQuery, and Databricks means your data team works with the same ground truth as your agents. Structured APIs for everything else.

MCP server - Claude queries your financial data directly, no custom plumbing
Warehouse sync - Snowflake, BigQuery, Databricks, natively
RBAC for agent tokens - scoped access, closed periods immutable
Every proposed write goes through dry-run validation before a human signs off
Fabric MCP - Claude query
// Claude queries Fabric MCP directly
fabric.query("margin_by_channel", {
period: "2025-Q3",
channels: ["shopify", "amazon"],
include_context: true
})
// Returns reconciled margin with full
// accounting context - no hallucination risk
→ { shopify_gm: 0.423, amazon_gm: 0.381,
variance_drivers: ["fees", "returns"],
reconciled: true, revenue_treatment: "ASC_606_on_shipment" }
✓ Zero custom plumbing · Works with Claude, GPT, any LLM
Control & safety

Autonomous -
but accountable.

No agent touches your books without a dry-run, a validation, and your sign-off. Closed periods are immutable. Agent tokens are role-scoped. Every proposed write action goes through validation before a human approves. Fabric is designed for production, at month-end, against your real data - not just the demo.

Closed periods are immutable - agents can read, never rewrite history
Agent tokens are role-scoped - least-privilege access built in
Every proposed write is a dry-run first - you approve before anything posts
Production-grade reliability - not just reliable in the demo
Agent write validation flow
1
Agent proposes journal entry
2
Fabric runs dry-run validation
3
Human reviews and signs off
✓
Entry posts to ledger
Built for real workflows

What teams build
on Fabric.

From exception handling to board narratives - the use cases that matter most to e-commerce finance teams, made reliable by clean data.

For CTOs & Engineering
A production-ready
financial data layer.
Fabric gives your team the trust infrastructure you'd otherwise spend months building. MCP server. Warehouse sync. RBAC for agent tokens. Immutability guarantees on closed periods. Already built, already production-grade.
For CFOs & Finance Leaders
The infrastructure your
AI strategy depends on.
Every AI agent you want to run on your finance data depends on one thing: clean, contextualized input. Fabric is what makes your AI strategy work - not just in the demo, but in production, against your real data, at month-end.
For the Board
The context layer that makes
financial AI trustworthy.
Without a reconciled, semantically-rich financial graph, AI agents on finance data hallucinate. With Fabric, they're reliable enough to run operations - not just generate reports.
Full capability set

Everything your team
needs to build on.

The complete Fabric capability set - production-ready infrastructure for financial AI, built specifically for e-commerce.

MCP server
Claude and any LLM can query your financial data directly - zero custom plumbing
⭐ Key capability
Warehouse sync
Native sync to Snowflake, BigQuery, and Databricks - reconciled data in your warehouse
⭐ Key capability
Structured APIs
RESTful APIs exposing the full financial graph - for any agent or internal tool
⭐ Key capability
Semantic financial graph
Every transaction encoded with GAAP-compliant treatment, e-commerce logic, and accounting semantics
✦ Differentiator
RBAC for agent tokens
Role-scoped access - least-privilege by design, closed periods immutable
✦ Differentiator
Dry-run validation
Every proposed write validated before posting - human sign-off required
✦ Differentiator
E-commerce-native context
Returns logic, ASC 606, fee waterfalls, gift card treatment - pre-encoded
Feature
Real-time event streams
Subscribe to transaction events as they're reconciled - for live agents
Feature
>1k integration combinations
Every channel, processor, bank, and ERP - no ETL for you to build or maintain
Feature
For CTOs & engineers

Stop feeding AI agents
fragments.

Give them ground truth. Fabric is the system of context your financial AI depends on - no integration code to build - you’re live in days, not months.

Book a demo →