Compose your stack

This is where product-agnostic becomes concrete. Prscnt composes whatever tools you already run — it builds no connectors of its own. The agent reads and writes your systems through your MCP connectors, in the same session, and Prscnt keeps a thin pointer so the two pipelines stay in sync.

Map your stack

Sort your tools into roles. Prscnt cares about the role, not the brand:

Role	What Prscnt does with it	Common tools
CRM / pipeline	Mirror deals to/from your records; pull your brand-contact graph in read-only	HubSpot, Salesforce, Close, Attio, Airtable, Monday
Spreadsheets / trackers	Read your rate card or deal tracker before acting, write results back	Google Sheets
Outbound / sales engagement	Read your sequences, opens, clicks, and replies and fold them into the pipeline	Mixmax
Team comms	Post deal updates and approvals to your channel, read team context	Slack
Project / tasks	Turn campaign milestones into tasks	Asana, Monday, ClickUp, Linear
Docs	Store briefs, SOPs, one-pagers	Notion
E-sign	Send contracts after redline	DocuSign
Email	Draft and (after approval) send outreach	Gmail (your own connector)
Accounting	Create invoices, reconcile payments	QuickBooks

Airtable and Monday are dual-use — many agencies run their entire CRM in them. Use whichever role fits how your team works.

This table is the common set, not the limit. Prscnt composes any tool you've connected an MCP for — if your stack includes something not listed here, connect its MCP and the agent will read from it, write back to it, and link it to the deal just the same.

How composition works

Three moving parts, no migration:

You connect your tool's own MCP in the agent's session (the official HubSpot MCP, an Airtable MCP, your QuickBooks MCP, etc.). It runs with your credentials.
The agent reads and writes your records through that connector.
Prscnt stores a pointer from its deal to your record so updates flow both ways. It never holds your data or credentials.

Pull your existing book in (read-only)

If your brand-contact graph already lives in a CRM or a base, import it as read-only intel so Prscnt's intelligence is grounded in your relationships. The agent reads the contacts through your connector, then hands them to Prscnt:

crm_import(source, contacts[])

source is your system (hubspot, salesforce, close, airtable, monday, …). Each contact is mapped to its brand and deduped by email, so re-running is safe. Prscnt never writes back to your CRM — this is intel ingestion only.

Keep the two pipelines in sync

When a deal moves in Prscnt, mirror it into your system, and vice versa. Three tools do this:

stack_link_deal(deal_id, system, external_id, url) — point a Prscnt deal at the matching record in your tool. Stores only the id + URL.
stack_resolve_deal(system, external_id) — the reverse lookup: given a record id from your tool, find the linked Prscnt deal. Use this when an update originates on your side.
stack_deal_refs(deal_id) — list everything a deal is linked to, so the agent mirrors changes into the right places.

The loop, in any stack:

1. crm_import           # bring your graph in, read-only
2. ...work happens...   # price / vet / draft / advance via Prscnt tools
3. deals_update_stage   # advance the Prscnt deal
4. (your connector)     # write the same change to your record
5. stack_link_deal      # keep the pointer current

The same flow, three stacks

The tool calls are identical. Only the connector and the UI trigger change.

Softr + Airtable. A Softr button fires your runner. The agent reads the Airtable row via the Airtable MCP, runs Prscnt intel, writes the result back to the row, and stack_link_deals the record (external_id is the Airtable rec… id).

Retool + HubSpot. A Retool button hits a query that calls your runner. The agent reads the HubSpot deal via the HubSpot MCP, runs the same Prscnt intel, updates the HubSpot record, and stack_link_deals it (external_id is the HubSpot deal id).

Custom app + Salesforce. Your app POSTs to the runner. The agent reads the opportunity via your Salesforce MCP, runs the same Prscnt intel, writes back, and links it (external_id is the Salesforce opportunity id).

Same brain, same tools, same outcome. That's the point.

The orchestration runner — the agent that runs this loop.
Recipes — full end-to-end flows.
Tool reference — every tool used above.