Data access gateway

One governed connection between your data and every agent on your team.

Connect your database, your APIs, and the MCP tools your team already runs. Every agent that queries through it gets the same masked, permissioned view — and what it finds can be shared as a live dashboard anyone you choose can open.

Connect your database →See how it works

Read-only by default · Your data never leaves your database · Free to start

teamduo — analytics-team workspace

1 · Connect & govern once

# connected sourcespostgres prod-db read-only# exposed to agentsresource mrr metric · verifiedresource active_usersresource orders (pii masked)deny customers.email, ssn
semantic layer · v14 ✓ reviewed

2 · Same question, two answers

You → Claude

What was our MRR last month vs the month before, by plan tier?

Claude · raw connection string

Scanning schema — 42 tables, no descriptions.

Is revenue invoices or subscriptions?

Should trials count? Which status means churned?

MRR was $151,880 — my best reading of it. Ask again and the number moves.

✗ definition guessed · the next teammate starts over

Claude · via TeamDuo

Reading mrr — defined once, reviewed, v14.

MRR rose 12.4% MoM to $148,200. Growth was led by the Team plan (+18%).

✓ logged · gated by your permissions

Connect the agents your team already uses

What you get

Three problems, one governed connection

Query access, shareable output, and one entry point — all scoped the same way.

  • Ask your database directly

    No more Slack-tagging the one person who knows SQL. Any team member can ask a real question through Claude, Cursor, or ChatGPT and get a real answer.

    • Documented once — schema, profiling, and a semantic layer teach every agent what your data means, so two people asking the same question get the same number.
    • Masked at the column level. An agent literally cannot request restricted data, whoever's asking.
    • Every question and every result is monitored, not just allowed once and forgotten.

  • A dashboard everyone can actually open

    A chart someone builds once becomes a link everyone can open — not a message trapped in one chat thread.

    • Opens live. It re-queries your database directly on every open, not through an MCP round-trip, so the number is the real one.
    • The creator decides who sees it, independent of the viewer's own database access — genuinely shareable, unlike a chat artifact.
    • Still there next week. It's a permanent link, not a conversation someone has to dig back up.

  • One gateway for every tool you connect

    Stop reinstalling the same access on every machine on your team.

    • Your own APIs become tools an agent can call — no MCP server to write by hand.
    • Every MCP server your team already runs moves behind the same one entry point.
    • Rotate or revoke centrally. Nobody has to touch a config file.

All three run on the same rails. Who can reach what is scoped per person and per agent, and every query, result, and artifact open is written to one access log.

Your sources

Connect the sources you already use. Bring the rest as you grow.

One governed gateway for every source your team connects — starting where your data already lives. As more land, a single Live Artifact can blend them: one dashboard instead of a spreadsheet stitched together by hand.

  • PostgreSQLAvailable
  • MongoDBAvailable
  • BigQueryAvailable
  • MySQLComing soon
  • SnowflakeComing soon
  • Google Analytics (GA4)Coming soon
  • Search Console (GSC)Coming soon
  • Google SheetsComing soon
  • GitHub (schema & docs)Coming soon

Need something else? Request a source →

The problem

Handing an agent your database is a footgun

Point an AI agent at a raw connection string and you inherit three problems at once.

  • There's no access control in a SELECT

    A raw connection can read every column in every table — including PII you never meant an agent, or the vendor behind it, to see.

  • The same question returns different answers

    Agents re-invent joins, filters, and metric math every time. Ask for "revenue" twice and get two numbers. No one trusts the output.

  • You can't see what happened

    No record of which agent ran what, when, or what came back. Impossible to audit, debug, or hand to security.

How it works

From connection string to governed endpoint in minutes

TeamDuo sits between your data and any agent — the layer that understands, governs, and logs every request.

  1. Connect your data

    Add a database connection, read-only by default. TeamDuo reads the schema so it knows what is there before anything is exposed.

  2. Auto-document it

    TeamDuo drafts a semantic layer from your schema and migrations — tables, columns, and metrics, described in plain language. You curate.

  3. Choose what's exposed

    Pick the resources agents can see. Mask columns, filter rows, and set who — which member, which agent — can reach what.

  4. Connect your agent

    Drop the TeamDuo MCP endpoint into Claude, Cursor, or ChatGPT. Your team runs live analysis and search — safely — and can publish what it builds as a Live Artifact for anyone with access to open.

Features

More than a database MCP server

The connection is the easy part. TeamDuo is the documentation, governance, and history around it.

  • Version-controlled semantic layer

    Every metric and definition is documented once, reviewed like code, and versioned — so answers are consistent and every change is traceable.

  • Auto-docs from your schema

    Bootstrap descriptions and business logic straight from your schema and migrations. No blank-page documentation.

  • Column masking & row filters

    Expose a table without exposing PII. Rules are enforced at query time — an agent literally cannot request forbidden data.

  • Roles & per-agent permissions

    Admins control exposure; members consume. Scope access per person and per agent, and revoke it in one click.

  • Immutable audit log

    Every agent query — who, what, when, what returned — captured and exportable. Debuggable by you, defensible to security.

  • Build & share live artifacts

    An agent can publish what it builds — a chart, table, or dashboard hosted at teamduo.ai that reconnects to your data on every open, not a frozen snapshot from a chat.

The difference

Your data's meaning, under version control

Text-to-SQL gives an agent access to your data. A semantic layer gives it understanding. TeamDuo makes that understanding a reviewable, versioned artifact your team owns — not a prompt someone pasted once.

  • Define a metric once; every agent uses the same math.
  • Review changes to definitions and exposure before they go live.
  • Roll back instantly when a change breaks an answer.
  • See who changed a definition, and when, on every version.
semantic/metrics/mrr.yml+ reviewed by tony
metric: mrr
label: Monthly Recurring Revenue
- filter: status = 'active'
+ filter: status = 'active' AND is_trial = false
+ grain: month
access: [admin, analyst]
mask: [customer_email]
Live Artifacts

Build once. Share live.

An agent doesn't just answer — it can publish. A Live Artifact is a chart, table, or dashboard your agent builds through the same governed connector, hosted at a permanent teamduo.ai link, that reconnects to your data every time someone opens it.

  • One link — no re-running the same prompt in your own chat to see it.
  • Opens current — re-queries live on every open, with a cache so a popular view doesn’t hammer your database.
  • Shared like a doc — the creator decides who sees it, independent of their own database permissions.
  • Logged — every open is recorded, the same as every query.
teamduo.ai/artifacts/mrr-by-plan
MRR by planLive
3 viewing · queried just now

A Live Artifact vs. Claude's Live Artifact

 A chat artifactClaude's Live ArtifactA Live Artifact
Where does it live?Inside one conversationOn your desktop app — tied to your computerA permanent teamduo.ai link
Who can open it?Whoever has that chat threadAnyone in your org with the link (Team/Enterprise only)Anyone you grant access to
When the data changes?Frozen — rerun it manuallyRe-queries on open, through an MCP connector callRe-queries on open, direct to your database or API
Who sees what?Same for everyone who sees the chatWhoever opens it, using their own connections — missing access shows an errorWhoever the creator grants access to — independent of their own database permissions
Version history?NoneEvery edit saved, restorableEvery version saved, restorable
Audit trail?NoneNot documentedEvery open logged
Why not a raw MCP server?

The gap that matters

CapabilityRaw DB MCP serverTeamDuo
Connect a databaseYesYes
Documented, consistent metricsNot supportedVerified & versioned
Column masking / row-level rulesNot supportedEnforced at query time
Team roles & per-agent accessNot supportedBuilt in
Audit log of every queryNot supportedImmutable & exportable
Change review & rollbackNot supportedGit-backed history
Security & trust

Built to be handed to your security team

  • Read-only by default

    Write access is opt-in and explicitly scoped. Safe is the default, not the config.

  • Your data stays put

    Queries run against your database. TeamDuo governs and logs access — it isn't a copy of your data.

  • Preview before you expose

    See exactly what an agent will see — masked columns and all — before anything goes live.

  • Live artifacts can't overload your source

    Opening a Live Artifact re-queries your database — it isn't a stored copy. A cache, shipping now, keeps a popular artifact from turning into repeated, identical load.

  • SSO & SOC 2 on the roadmap

    SAML/OAuth SSO and SOC 2 Type II for teams that need the paperwork.

Give your agents data they can trust.

Connect your first database in minutes. Free while you build — governance and team plans when you're ready.

Start free →Book a demo
Talk to us

Tell us what you need

Let us know what you need, or share any feedback.