A knowledge map for each connection that guides agents to the right data, definitions, and business logic — whether answering ad hoc questions or building dashboards.
An agent reads the source's metadata and compiles it into readable pages: schema with meaning, the rules and automations that decide what your terms actually mean, and the queries that already ran clean. When the source changes, the wiki updates diff by diff.
Schema, rules, and definitions resolved here
Salesforcesales_read
Snowflakeanalytics_ro
Postgresapp_read
Jiraissues_readEvery connected source gets its own wiki, and the pages link to each other. As you add sources, that grows into one connected context — the same customer traced through CRM, tickets, and billing.
Secure connections# The agent reads the wiki before it queries.▸ wiki Opportunity · schema + meaning▸ wiki rules · what "qualified" means here▸ wiki examples · joins that ran clean$ mp.run("slipped_deals.sql")# Starts from proof · not from guesses.▍
Agents read the relevant pages before touching the source, so they start with the right objects, fields, joins, and rules in view instead of burning tokens rediscovering them.
Governed workspaceCompiled by an agent · corrections kept as revisions
Plain, versioned, diffable pages inside your deployment — not rows in a proprietary metadata store. Read it like documentation, correct it like a doc, review changes like code.
Trust and governanceStaleness is the design target. Maintenance is continuous agent work driven by diffs in the source, not a quarterly documentation project nobody is assigned to.
Provision a connection and the first wiki compiles in hours · objects, automations, and the business motion behind the schema.
Each agent reads the relevant pages before it acts · right fields, right joins, rules respected, and different agents give answers that agree.
Successful queries and joins are harvested back in, and so are your team's corrections. The next agent starts from proof, not guesses.
Health checks flag broken links, new fields, changed flows, and synthesis that no longer matches the schema — so the map keeps matching the territory.
Two analysts ask about the same customer from different assistants. Both agents read the same pages first, so the definitions, filters, and joins behind the answers match.
A connected org returns schema pages, an automations atlas, and a synthesis of the sales motion as it really runs — including the validation rules that decide what 'qualified' means.
A new field lands and a flow changes. The wiki updates diff by diff, health checks flag what no longer matches, and the team corrects the page instead of rewriting docs.
A catalog is written by people and read by people · And it bit-rots between review cycles. The wiki is compiled and maintained by an agent, and its first reader is another agent. It captures what catalogs miss · The automations, the business rules, the joins that actually work · Because agents need those to answer correctly.
An agent does. Connect a source and it crawls the metadata · Schema, automations, flows, validation rules · And compiles readable pages. When the source changes, the wiki updates diff-by-diff. Your team reads, reviews, and corrects; nobody is assigned to "keep the docs up to date."
Yes. The wiki is plain, versioned, diffable pages · Not rows in a proprietary metadata store. Read it like documentation, correct it like a doc, review changes like code. It's readable, exportable, and yours.
Every agent working through the MarcoPolo workspace reads the relevant wiki pages before touching the source. It starts with the right objects, fields, joins, and rules in view · Instead of burning tokens rediscovering them · And different agents give answers that agree.
Any system you've set up in LiveConnect. Salesforce is the deepest example today · Schema pages, an automations atlas, sales-motion synthesis · With the same approach applying across databases, warehouses, and SaaS systems.
Each connected source gets its wiki today, and the pages link to each other. As you add sources, that grows into one connected context across systems · The same customer traced through CRM, tickets, and billing. That cross-system graph is where this is headed.
Staleness is the design target. Updates are driven by diffs in the source · A new field, a changed flow · And health checks flag drift, broken links, and synthesis that no longer matches the schema. Maintenance is continuous agent work, not a quarterly project.
Inside your workspace, in your deployment · Your VPC or on-premise. Like everything in the workspace it's a versioned artifact · Portable files, no lock-in on your semantics.
Same data gateway, same governance model. What changes is who is driving and where the work is written.
Governed connections, managed execution, and audit inside the agent you ship.
Read the Agent SDK pageAgent ConsoleProvision access, review what agents did, and hold the controls in one place.
Read the Agent Console pageOne MCPOne governed tool surface that Claude, ChatGPT, Cursor, and Copilot can use.
Read the One MCP pageLiveConnect100+ live enterprise systems behind the same six verbs, scoped per user and agent.
Read the LiveConnect page
Connect a source and get back a wiki of it · Objects, automations, the sales motion as it really runs. The fastest way to see what your agents have been missing.
