LLMs guess which fields match across systems. For reads, that's annoying. For writes, that's a production incident. Manifold maps every relationship — field names, data formats, entity matches — at build time, so your agent writes to any connected system with the same accuracy as hand-written integration code. No guessing. No LLM in the loop at runtime.
Your AI agent can query your systems today. It works... mostly. Wrong matches are annoying but survivable — the user asks again, the agent retries. But the moment your agent writes — updates a customer record, syncs an invoice, changes a billing address — "mostly works" becomes "corrupted production data across every system it touched." That's the line most teams won't cross. Manifold makes it safe to cross it.
Every system names its fields differently. cust in one is VendorRef in another is contact_id in a third. The LLM guesses from context which fields correspond. For a read, it might pull the wrong related record. For a write, it updates the wrong field in production. Manifold knows the exact mapping — verified at build time, not guessed at runtime.
"Update the invoice in System B that matches this charge in System A." The LLM finds two invoices with similar amounts, picks one. If it's wrong, you've updated the wrong customer's record. Manifold resolves entity matches once, deterministically, with confidence scores. Same match every time.
Your agent updates a record in one system. The same entity exists in three other systems — but those stay stale. Or worse, the LLM tries to sync them and writes a field name from one system as a literal value in another. Manifold translates field names and formats across systems automatically.
When the LLM writes to multiple systems, what exactly changed? Which field, which record, which system? If something goes wrong, can you roll it back? Without Manifold, you're reading API logs across separate dashboards. With Manifold, every write returns a receipt and is reversible.
You've hand-built one integration between two systems. It took a sprint. Now do it for 10 systems. The LLM approach doesn't scale because the error rate scales with it. Manifold's accuracy is the same whether you have 2 systems or 20.
import manifold
m = manifold.Manifold()
# Point Manifold at your existing code — any system, any domain
m.connect("billing", stripe_client)
m.connect("accounting", quickbooks_module)
m.connect("crm", hubspot_client)
m.connect("inventory", warehouse_api)
# Manifold discovers types, classifies fields, maps cross-system relationships
m.discover()
# Hand the tools to your LLM — one unified interface across all systems
tools = m.tool_definitions()Now your agent takes over. You give it the tools — it decides what to call, when, and why.
manifold_list_types()manifold_describe_type("stripe", "charge")manifold_search("stripe", "charge", {"cust": "acct-1"})manifold_get("stripe", "charge", "ch-1001")manifold_get("qbo", "bill", "201")manifold_update("hubspot", "contact", "501", {"email": "new@acme.com"})manifold_sync("hubspot", "contact", "501")That last one is the one that matters. The agent updated one field in one system, and Manifold propagated it to every connected system — translating field names, matching the right records, and returning a receipt showing exactly what changed where. No LLM reasoning. No guessing. No "I think this is the right field."
Your agent reads with full cross-system context and writes with automatic propagation. One call, every system updated — with the right field names, the right format. The agent makes decisions. Manifold handles the plumbing.
Update once, sync everywhere. Because Manifold knows the exact entity matches and field mappings, your agent can update a record in one system and Manifold propagates the change to every connected system — right field names, right format. This is the feature that turns "read-only AI agent" into "AI agent that actually does things."
# Update a customer — Manifold handles cross-system propagation
m.execute("manifold_update", {
"source": "hubspot",
"type": "contact",
"id": "501",
"fields": {"email": "new@acme.com"}
})
# → Also updates stripe.account.acct-1 and qbo.vendor.56
# because Manifold knows they're the same entityThe reason writes are safe. Manifold builds a verified mapping between every connected system — field to field, record to record. These mappings are built at connect time and never change until you reconnect. Deterministic. Auditable.
m.discover()
# ✓ 4 sources connected
# ✓ 23 entity types discovered
# ✓ 47 intra-source relationships mapped
# ✓ 12 cross-source relationships foundPass in a Python module, an SDK client, or an OpenAPI spec. Manifold inspects your existing code — function names, signatures, docstrings — and figures out the data model. You don't write adapters.
# Your existing Stripe client — unchanged
m.connect("billing", stripe_client)
# Or an OpenAPI spec
m.connect("erp", spec="https://api.internal.co/openapi.json", auth={...})Manifold pulls representative samples, builds a schema graph, and uses an LLM to classify every field — identifiers, references, categories. It understands that cust on a charge points to an account, that VendorRef on a bill points to a vendor.
One set of tools that spans your entire data landscape. Feed them to Claude, GPT, Gemini — framework agnostic. Or connect via MCP. No LLM calls at runtime — it's a graph lookup.
# Tool definitions — works with any LLM framework
tools = m.tool_definitions()
# Or serve via MCP
m.serve_mcp(port=8080)manifold_get()manifold_update()manifold_sync()The LLM runs at build time — when you connect a system. At runtime, every read is a graph lookup and every write is a verified propagation through the cross-source mapping. The mapping was built by the LLM, verified against real data, and frozen. Your agent never guesses at runtime. That's why writes are safe.
manifold_list_types["stripe.charge", "qbo.bill", ...]manifold_describe_typecharge has 8 fields, cust is a reference to accountmanifold_getch-1001 with cross_source_matches: [{qbo.bill.201}]manifold_searchmanifold_search("stripe", "charge", {"status": "paid"})manifold_follow_referencecharge.cust on ch-1001 → account.acct-1manifold_cross_referencesch-1001 matches qbo.bill.201 (0.95)manifold_updateqbo.vendor.56 email to "new@acme.com"manifold_synchubspot.contact.501 → updates Stripe + QBOmanifold_createEvery write tool returns a receipt: exactly what changed, in which system, which fields, old values and new values. Every write is reversible. This is not "fire and forget" — it's "act and verify."
manifold_type_mappingstripe.charge → qbo.bill: amt→TotalAmtmanifold_sync_previewqbo.vendor.56.PrimaryEmailAddrmanifold_auditOne tool set. Not per-system, not per-group. Your agent reads, writes, inspects, and syncs across the full graph.
Most integration tools stop at querying. Manifold goes further — because it understands the data linkages across every connected system, your agent can write to one system and Manifold ensures the change is reflected everywhere.
Agent tries to update email across systems:
1. Updates hubspot.contact.501.email → "new@acme.com" ✓
2. Searches Stripe for matching account...
finds 3 results... picks stripe.account.acct-7
(wrong one — same company name, different entity)
→ Updates wrong customer's email in Stripe
3. Searches QuickBooks for matching vendor...
tries to write "email" to field "PrimaryEmailAddr"
→ API rejects the field name, or worse: creates a new field
Result: 1 correct update, 1 wrong customer, 1 failed writeAgent calls: manifold_update + manifold_sync
1. hubspot.contact.501.email → "new@acme.com" ✓
2. stripe.account.acct-1.email → "new@acme.com" ✓
3. qbo.vendor.56.PrimaryEmailAddr → "new@acme.com" ✓
Entity matches: verified at build time (confidence 0.97)
Field mapping: exact (email → email → PrimaryEmailAddr)
Receipt: returned with old/new values for each system
Reversible: yes
Result: 3 correct updates, auditable, reversibleManifold maps fields across systems — it knows which field in System A corresponds to which field in System B. Updates are translated automatically using the cross-source field mapping built at discover time. No LLM in the loop. No guessing.
Cross-system writes are auditable and reversible. Every sync operation returns a receipt showing exactly what changed where, and Manifold can roll back individual updates. Your agent acts with confidence because Manifold acts with precision.
Your agent pulls a Stripe charge and automatically gets the matching QuickBooks invoice, linked journal entries, and the customer record across all systems. When the charge is refunded, it updates the matching bill in QuickBooks automatically.
Your agent checks a Shopify order and gets the linked warehouse fulfillment, shipping status, and inventory levels in one call. When stock changes, it updates counts across Shopify and the warehouse system automatically.
Your agent looks up a customer and gets their subscription, latest invoice, and matching ERP record — all linked, one query. When the support agent updates the customer's address, Manifold propagates it to billing and shipping systems.
Your agent updates a billing address in one system. Manifold pushes the change to every connected system where that entity exists — each with the right field names, the right format. One call, every system current.
Your agent pulls a PagerDuty incident and gets the linked Jira ticket and GitHub PR automatically. When the incident is resolved, it closes the ticket and merges the PR — all through the graph.
Connect your internal APIs with m.connect("inventory", warehouse_api). Manifold discovers the schema and maps it to your existing systems. No integration sprint required.
There are no "supported systems." Manifold doesn't ship pre-built connectors. It inspects whatever you give it — any Python SDK, any REST API, any internal service — and figures out the data model.
m.connect("billing", stripe_client)m.connect("inventory", warehouse_module)m.connect("erp", spec="https://...", auth={...})Any domain. Any system. If your code can call it, Manifold can discover it.
Manifold ships as a Python package. Install it, run it locally, keep your data in your infrastructure. No SaaS dependency, no data leaving your network.
We're building the hosted version for teams that want managed discovery, a dashboard for reviewing cross-source mappings, automatic re-sync when schemas change, and a full audit log of every cross-system write. The waitlist is for early access to both.
Every cross-system write is logged, auditable, and reversible. The Python library includes manifold_audit() and manifold_sync_preview() so you can inspect what will happen before it happens, and trace what did happen after.
$ pip install manifoldManifold works. Now we need your systems to prove it. We're running a closed beta to stress-test cross-system writes against real integrations, real edge cases, real data models. Your use case shapes what we ship. Early access is free.
We'll only email you about beta access and product updates. Nothing else.