Manifold connects your APIs, discovers the data model, maps relationships across systems, and exposes everything as one set of LLM tools. Your agent reads across all systems, writes to one, and Manifold auto-syncs the change everywhere — right field names, right format, every system. No integration code. No LLM in the loop at runtime.
You can hand your LLM 50 API tools and it'll call them. But when it needs to work across systems — match a Stripe charge to a QuickBooks invoice, update a customer's email in three places — it guesses. It gets it wrong. And every time it tries, it reasons differently. You can't build reliable systems on probabilistic cross-system reasoning.
"Find the matching QuickBooks invoice for this Stripe charge." The LLM fetches from both systems, compares amounts and dates, and picks one. Sometimes it's right. Sometimes it matches the wrong invoice — same amount, different customer. You don't find out until the data is corrupted. Manifold resolves matches once, verifies them, and returns the same correct answer every time.
Ask the same cross-system question twice, get two different reasoning paths. The LLM might match on amount today and date tomorrow. There's no consistency, no auditability, no way to debug when it's wrong. Manifold's mappings are deterministic — same query, same answer, every time.
The LLM doesn't know that Stripe's cust is QuickBooks' VendorRef is HubSpot's contact_id. It guesses from context. For reads, a wrong guess is confusing. For writes, a wrong guess corrupts production data across multiple systems. Manifold knows the exact field mapping — verified at build time, not guessed at runtime.
10 systems × 20 entity types × 3 operations = 600 tools. LLMs pick the wrong tool more often as the tool set grows. Manifold gives you 12 tools that span everything — the LLM always picks the right one.
When the LLM gets cross-system reasoning wrong, you retry, add more context, chain more calls. You're burning tokens to compensate for a lack of ground truth. Manifold provides the ground truth — the relationships are pre-computed. Zero reasoning tokens, zero retries.
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")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.
Pass 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.
Manifold finds that Stripe's charge is QuickBooks' bill. That charge.amt maps to bill.TotalAmt. That ch-1001 and BILL-2025-001 are the same transaction. Built once at connect time, queried deterministically at runtime.
Manifold doesn't just read — it writes back. Your agent can update a record in one system and Manifold automatically propagates the change to every connected system where that entity exists.
# 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 entityOne 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 and every write is a deterministic graph operation. Reads are lookups. Writes propagate through the cross-source mapping automatically. No tokens burned, no latency, no hallucination risk.
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_createmanifold_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: "Update Acme Corp's email to new@acme.com"
Manifold knows:
hubspot.contact.501 ←→ stripe.account.acct-1 ←→ qbo.vendor.56
All three are Acme Corp.
Manifold executes:
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"
Each system gets the update in its own field format.
The agent made one call. Manifold handled the rest.Manifold maps fields across systems — it knows that HubSpot's email is Stripe's email is QuickBooks' PrimaryEmailAddr. 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.
"Show me the Stripe charge for Acme Corp and its matching QuickBooks invoice." Your agent follows references across both systems without custom logic.
"Which Shopify orders are still unfulfilled in our warehouse system?" Manifold knows that a Shopify order maps to a warehouse fulfillment request — your agent queries across both without knowing either API.
"What's the status of this customer's subscription, their latest invoice, and the matching record in our ERP?" One query path across three systems.
"Update Acme's billing address in all systems." Your agent makes one call. Manifold updates the Stripe account, the QuickBooks vendor, and the HubSpot contact — each with the right field names, the right format.
"Link this PagerDuty incident to the Jira ticket and the GitHub PR that caused it." Manifold already knows the incident, ticket, and PR are connected — your agent navigates 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.
$ pip install manifoldManifold is in early access. Join the waitlist to get notified when we ship, and get early access to the Python library.
We'll only email you about product updates and early access. Nothing else.