Announcing CIMD support for MCP Client registration
Learn more

Tactiq MCP vs Tactiq API for AI Agents (2026)

Hrishikesh Premkumar
Founding Architect

TL;DR

  • Tactiq ships a remote MCP server with nine tools for meeting search, AI summaries, artifacts, transcript excerpts, and paged transcripts. Nothing writes back to Tactiq.
  • Tactiq publishes no public REST API reference. Outside MCP, data leaves through push paths: Tactiq Workflows and a Zapier trigger. Neither lets an agent query meeting history.
  • MCP auth is browser-based OAuth with four mcp:meetings:* scopes and no static API keys. Summaries and transcripts need a Tactiq Team seat.
  • Limits are per user: full transcripts for 10 distinct meetings an hour, excerpts for 100. A shared account cannot model per-user access.
  • Scalekit's Tactiq MCP connector vaults and refreshes each user's grant, scopes tools per user, and logs every call to the user who authorized it.

Your agent needs what was said in the meeting

Your agent has to answer questions about meetings: the pricing concession on Tuesday's call, the action items from standup, the commitment a customer made three weeks ago. Tactiq already holds those transcripts. So you go looking for its developer surface and find a hosted MCP server, and no public REST API reference.

That changes the usual MCP vs API framing. The real choice is between an agent that pulls meeting context on demand through MCP, and pipelines that receive meeting data when Tactiq pushes it. Here's how the two compare, and how to run the MCP path in production.

What Tactiq MCP and the Tactiq API actually are

Only one of these is an interface an agent can query. That asymmetry drives everything below.

Tactiq MCP: remote, OAuth-only, read-focused

Tactiq builds and maintains a remote, HTTP-based MCP server at mcp.tactiq.io. There is nothing to install locally. Tactiq positions the same endpoint for Claude, Claude Code, Cursor, ChatGPT, Codex, and n8n, and it is a verified connector in Claude's directory.

Authorization is a browser-based OAuth sign-in. Tactiq's help center is explicit that there are no static API keys. The server exposes nine tools, and every one reads data. The single side effect: get_meeting starts summary generation when a meeting has no summary yet.

Access mirrors Tactiq's own sharing model. An agent sees the owned, shared, team, and space meetings the signed-in user can already open, and nothing more.

The Tactiq API: push paths, not a query surface

Tactiq does not publish a public REST API reference, a developer portal, or an API key flow. Its help center documents three programmatic surfaces: the MCP server, Tactiq Workflows, and a Zapier integration.

Workflows are post-meeting pipelines configured under My Workflows in the Tactiq dashboard. They run AI prompt steps and share the output to integrations such as Slack, Notion, HubSpot, and Linear, or email it to participants. Tactiq's Zapier app exposes a trigger that fires when a meeting transcript is ready.

Both push data forward after a meeting ends. Neither accepts a question. For the rest of this comparison, "the API path" means these push channels, because they are what exists.

Comparing them where it matters for agents

Four dimensions matter: capability, auth, operational surface, and fit. The capability gap here is structural, so start there.

What your agent can actually do

Tool names below are Tactiq's own. Scalekit's connector prefixes each one with tactiqmcp_.

Capability
Tactiq MCP
Workflows and Zapier
List recent meetings
Yes, any plan (list_recent_meetings)
No
Search by topic, participant, date
Yes, any plan (search_meetings)
No
Read the AI summary
Team plan (get_meeting)
Pushed post-meeting
Read action items, drafts, CSVs, decks
Team plan (get_meeting_artifact)
Pushed as step output
Find verbatim quotes for a question
Team plan (get_transcript_excerpts)
No
Expand context around a quote
Team plan (expand_transcript_excerpt)
No
Read the full transcript
Team plan, paged (get_transcript)
Pushed post-meeting
Poll async summary generation
Yes (get_generation_status)
Not applicable
React when a transcript is ready
No event surface
Yes
Query older meetings on demand
Yes
No
Create, edit, share, delete meetings
No
Not documented

Query surface vs event surface

The pattern is clean. MCP is a query surface with no events; the push paths are events with no query surface. Neither writes to Tactiq, so an agent that acts on a meeting (updates a CRM record, posts a Slack follow-up, files a Linear issue) always needs a second connector. Tactiq agents are multi-tool agents by construction.

Async summaries and expiring references

Tactiq's tool descriptions carry an operating contract the model has to follow. get_meeting never returns the full transcript. If no summary exists, it returns detailedSummary: { status: 'generating', jobId }, and the agent polls get_generation_status until the status is ready. A failed status is terminal; the fix is a fresh get_meeting call.

Excerpt references expire. An excerptId from get_transcript_excerpts stops working after about an hour, so an agent cannot cache excerpt IDs across sessions. Each excerpt call returns at most 10 moments. An empty list means nothing matched the wording, not that the topic never came up, so prompts that rephrase before concluding "not discussed" produce better answers.

Per-user rate limits shape the design

Full transcripts through get_transcript are capped at 10 distinct meetings per hour per user. Excerpt reads are capped at 100 distinct meetings per hour per user. Meetings already read inside the window don't count again.

That ceiling settles a design question. An agent that pulls full transcripts to "be thorough" can exhaust its hourly budget on a single research question across a quarter of calls. The server is built for excerpts-first retrieval: search for the meeting, read the AI summary, then pull the specific quotes. Full transcripts are for jobs that need the whole text, like translation. Leaving get_transcript out of an agent's tool surface is often the right default.

The auth path each one puts you on

The MCP path is OAuth only. A user completes a browser consent screen and grants some or all of four scopes: mcp:meetings:own for their own meetings, mcp:meetings:shared for meetings shared with them, mcp:meetings:spaces for shared spaces, and mcp:meetings:details for summaries, AI artifacts, and transcripts. Revoking the grant from Tactiq's MCP settings invalidates access immediately.

The push paths authenticate differently. A Workflow runs inside the Tactiq account of the user who built it and holds credentials for each destination. A Zap runs under the Zapier account that connected Tactiq. In both cases the credential lives in a system your agent does not control.

Plan gating fails at call time, not connect time

Any Tactiq user can connect. Free and Pro plans allow search and list; details, summaries, and transcripts need a Team seat. The connect step succeeds either way, so the failure surfaces later as a tool error naming the missing mcp:meetings:details permission.

Upgrades don't fix existing grants. Tactiq's help center notes that a connection keeps the permissions approved when it was created, so a user who upgrades must reauthorize. Your agent needs a code path for this: detect the permission error and send that user a fresh authorization link.

Consent needs a browser once. After that, a server-side OAuth client that stores and refreshes the token can call the server without the user present, which is how background agents work here.

What you own in production

On the MCP path, Tactiq owns tool schemas, summary generation, transcription, and access rules. You own everything around the grant: OAuth client registration, per-user token storage, refresh, revocation handling, plan and scope errors, per-user rate-limit backoff, and tenant isolation. Tool schemas are defined server-side, so they change when Tactiq ships changes. Pin expected behavior with integration tests, not a version header.

On the push path, you own a receiving system and, with it, a copy of every transcript that lands there. That copy needs retention rules, access control, and deletion that stay consistent with Tactiq's own sharing model. A trigger fires on new transcripts; it does not backfill history, so questions about older meetings still need MCP.

When Tactiq MCP is the right path

Use Tactiq MCP when:

  • The agent answers questions over meeting history on demand, such as "what did Acme agree to on pricing last month?"
  • Answers need verbatim quotes with speaker, timestamp, and a link that opens the call at that moment.
  • The agent combines meeting context with other tools: prepping a 1:1 from the calendar plus past calls, or drafting a CRM update from a discovery call.
  • Each user's access must mirror Tactiq's sharing rules exactly, including team and space meetings.

When Workflows or Zapier are the right path

Use the push paths when:

  • Every meeting should produce the same artifact with no reasoning loop, such as a summary in a Notion database or action items in Linear.
  • The job is event-driven and must start the moment a transcript is ready; MCP has no event surface.
  • Every future full transcript should land in a system of record, and a 10-meetings-per-hour transcript cap would throttle that.
  • The owner is an ops team configuring automations, not engineers shipping an agent.

Production designs often use both: a workflow or Zapier trigger as the signal, and an MCP-backed agent that finds the meeting and reasons over it.

The credential problem that exists on both paths

Neither path removes per-user credentials. Each one just puts them in a different place.

One grant per Tactiq user

In a B2B agent, each of your customers' users has their own Tactiq account, plan, and sharing graph. Two hundred users means two hundred OAuth grants, each with its own scope set, plan status, refresh cycle, and revocation state.

A shared Tactiq account is not a shortcut. MCP returns what the signed-in identity can open, so a shared account hands one person's view of Tactiq to every user of your product: too little for most of them, far too much for the rest. The push paths are no better, because each Workflow or Zap is bound to the user who configured it. What the user can't do, the agent can't do, and that only holds when the agent acts with the user's own grant.

What neither path gives you

Tactiq issues the grant. It does not give you a vault for two hundred of them, per-tenant isolation, refresh orchestration, a re-consent flow when a user upgrades to Team, or an audit trail of which agent read which transcript on whose behalf.

Meeting transcripts are some of the most sensitive data an agent will touch: pricing, hiring decisions, board discussions. The token lifecycle around them is infrastructure, whichever path you choose.

Recommended reading: How to Handle Token Refresh for AI Agents

Where Scalekit fits

Scalekit's Tactiq MCP connector handles the OAuth 2.1 flow, including Dynamic Client Registration (DCR), and stores each user's tokens in an AES-256 vault namespaced per tenant. Tokens refresh automatically and are resolved server-side at request time, so credentials never touch the agent runtime or the LLM context. Every call is scope-checked and logged against the user who authorized it. The MCP vs push decision stops changing your auth infrastructure.

Building a Tactiq agent with Scalekit and LangChain

The walkthrough below uses Python and LangChain. It calls Tactiq's tools through Scalekit's execute_tool first, then moves the same agent behind a Virtual MCP server. The Tactiq MCP connector docs list every tool and its parameters.

Set up the connection and credentials

Create a Tactiq MCP connection in the Scalekit dashboard under AgentKit, then Connections. The connection name you set there must match TACTIQ_CONNECTION_NAME exactly; a mismatch is the most common integration error. Users who need summaries or transcripts need Tactiq Team seats.

pip install scalekit-sdk-python langchain-openai python-dotenv
# .env SCALEKIT_ENVIRONMENT_URL=<your-environment-url> SCALEKIT_CLIENT_ID=<your-client-id> SCALEKIT_CLIENT_SECRET=<your-client-secret> TACTIQ_CONNECTION_NAME=tactiqmcp # must match the dashboard connection name OPENAI_API_KEY=<your-openai-key>

Connect each user once

Each user authorizes Tactiq once. get_or_create_connected_account returns that user's connected account, and get_authorization_link produces the consent link while it isn't active yet.

import os from dotenv import load_dotenv from scalekit import ScalekitClient load_dotenv() scalekit_client = ScalekitClient( env_url=os.environ["SCALEKIT_ENVIRONMENT_URL"], client_id=os.environ["SCALEKIT_CLIENT_ID"], client_secret=os.environ["SCALEKIT_CLIENT_SECRET"], ) actions = scalekit_client.actions # Must match the connection name in AgentKit > Connections exactly CONNECTION_NAME = os.getenv("TACTIQ_CONNECTION_NAME", "tactiqmcp") USER_ID = "user_123" # your app's stable identifier for this user def ensure_tactiq_connected(identifier: str) -> None: response = actions.get_or_create_connected_account( connection_name=CONNECTION_NAME, identifier=identifier ) if response.connected_account.status == "ACTIVE": return link = actions.get_authorization_link( connection_name=CONNECTION_NAME, identifier=identifier ) print("Authorize Tactiq:", link.link) input("Press Enter after completing the Tactiq consent screen...") response = actions.get_or_create_connected_account( connection_name=CONNECTION_NAME, identifier=identifier ) if response.connected_account.status != "ACTIVE": raise RuntimeError( f"Tactiq is {response.connected_account.status}, not ACTIVE" ) ensure_tactiq_connected(USER_ID)

In production, redirect the user to the link instead of blocking on input(). Tell users to keep the meeting-details permission selected on Tactiq's consent screen, or summary reads fail later. The same function doubles as the re-consent path after a plan upgrade.

Retrieve the tools this user is authorized to call

The agent is not loading a connector catalog. It is loading the tools this user's connected account is authorized to call, and a tool_names filter narrows that surface further. The LangChain adapter wraps list_scoped_tools and returns native StructuredTool objects.

TACTIQ_TOOLS = [ "tactiqmcp_search_meetings", "tactiqmcp_list_recent_meetings", "tactiqmcp_get_meeting", "tactiqmcp_get_generation_status", "tactiqmcp_get_transcript_excerpts", "tactiqmcp_expand_transcript_excerpt", ] # Scoped to this user's connected account, then filtered to six tools tools = actions.langchain.get_tools( identifier=USER_ID, connection_names=[CONNECTION_NAME], tool_names=TACTIQ_TOOLS, page_size=100, ) tool_map = {t.name: t for t in tools} print(sorted(tool_map))

tactiqmcp_get_transcript is left out deliberately; the 10-meetings-per-hour budget is too tight for an agent that might reach for it reflexively. Six tools instead of nine. Tool bloat is an accuracy problem and a cost problem, and scoped surfaces fix both.

Run the agent loop

Each tool invocation runs execute_tool with the user's vaulted credential. Plan and scope failures come back as tool results rather than exceptions, so the model can tell the user to upgrade or reauthorize. Today's date goes into the system prompt so date-range searches resolve correctly.

from datetime import date from langchain_openai import ChatOpenAI from langchain_core.messages import HumanMessage, SystemMessage, ToolMessage MAX_STEPS = 15 llm = ChatOpenAI(model="gpt-4o").bind_tools(tools) messages = [ SystemMessage( f"Today is {date.today().isoformat()}. You answer questions about the " "user's Tactiq meetings. Find meetings with the search tools, read " "summaries with tactiqmcp_get_meeting, and cite transcript excerpts with " "their url. If a summary is still generating, poll " "tactiqmcp_get_generation_status." ), HumanMessage( "What did we commit to Acme on pricing in the last 30 days? " "Quote the exact lines." ), ] for _ in range(MAX_STEPS): response = llm.invoke(messages) messages.append(response) if not response.tool_calls: print(response.content) break for tc in response.tool_calls: # Scalekit resolves this user's Tactiq token server-side for each call result = tool_map[tc["name"]].invoke(tc["args"]) messages.append(ToolMessage(content=str(result), tool_call_id=tc["id"])) else: raise RuntimeError("Agent exceeded its step budget")

Multi-tool and multi-tenant agents with a Virtual MCP server

Because Tactiq MCP is read-only, useful Tactiq agents pull from more than one system. A meeting prep agent needs tomorrow's events from Google Calendar and past context from Tactiq. Virtual MCP servers give that agent one scoped endpoint: one server definition per agent role, and a short-lived session token per user per run. There is no MCP server to deploy, host, or maintain.

Define the server once per agent role

The server definition declares exactly which connections and tools the agent can see. Both connection names must match the dashboard.

# Continues from the earlier blocks (actions, CONNECTION_NAME) from scalekit.actions.models.mcp_config import McpConfigConnectionToolMapping vmcp = actions.mcp.create_config( name="meeting-prep-agent", connection_tool_mappings=[ McpConfigConnectionToolMapping( connection_name="googlecalendar", tools=["googlecalendar_list_events"], ), McpConfigConnectionToolMapping( connection_name=CONNECTION_NAME, tools=[ "tactiqmcp_search_meetings", "tactiqmcp_get_meeting", "tactiqmcp_get_generation_status", "tactiqmcp_get_transcript_excerpts", ], ), ], ) config_id = vmcp.config.id mcp_server_url = vmcp.config.mcp_server_url # static; reuse for every user

Five tools across two connections, instead of Tactiq's nine plus the full Google Calendar connector catalog. The endpoint is static; the identity is not.

Check connections and mint a session token

Before each run, confirm the user has active grants on every connection in the server, then mint a token bound to that user.

from datetime import timedelta def mint_session(identifier: str) -> str: accounts = actions.mcp.list_mcp_connected_accounts( config_id=config_id, identifier=identifier, include_auth_link=True, ) pending = [ a for a in accounts.connected_accounts if a.connected_account_status != "ACTIVE" ] if pending: for a in pending: print(f"{a.connection_name} needs auth: {a.authentication_link}") raise RuntimeError("Connect all accounts before running the agent") return actions.mcp.create_session_token( mcp_config_id=config_id, identifier=identifier, expiry=timedelta(minutes=30), ).token

Session tokens default to about an hour. Set expiry above the expected run time, and call create_session_token again for the next run; that call is the remint, and there is no separate refresh endpoint.

Connect LangChain to the Virtual MCP endpoint

LangChain reaches the endpoint through langchain-mcp-adapters, with the session token as a bearer header.

pip install "langchain-mcp-adapters>=0.3,<1"
# Reuses ChatOpenAI, the message classes, date, and MAX_STEPS from the loop above import asyncio from langchain_mcp_adapters.client import MultiServerMCPClient async def run_prep_agent(identifier: str, question: str) -> str: token = mint_session(identifier) client = MultiServerMCPClient( { "scalekit": { "transport": "streamable_http", "url": mcp_server_url, "headers": {"Authorization": f"Bearer {token}"}, } } ) mcp_tools = await client.get_tools() mcp_tool_map = {t.name: t for t in mcp_tools} llm = ChatOpenAI(model="gpt-4o").bind_tools(mcp_tools) messages = [ SystemMessage(f"Today is {date.today().isoformat()}. Prep the user for upcoming meetings."), HumanMessage(question), ] for _ in range(MAX_STEPS): response = await llm.ainvoke(messages) messages.append(response) if not response.tool_calls: return response.content for tc in response.tool_calls: result = await mcp_tool_map[tc["name"]].ainvoke(tc["args"]) messages.append(ToolMessage(content=str(result), tool_call_id=tc["id"])) raise RuntimeError("Agent exceeded its step budget") print(asyncio.run(run_prep_agent( "user_123", "Prep me for tomorrow's customer calls using what we discussed with them before.", )))

One server definition now serves every user in every tenant. User A's session token resolves user A's Tactiq and Calendar grants; it cannot reach user B's. For a complete version of this pattern, start from the sales call prep agent template.

Observability: every downstream Tactiq call, attributed

Tool-level logs are what turn a working demo into an agent a security team will approve.

What gets logged

Every Tactiq tool call Scalekit executes for your agent is logged with full attribution: who authorized it, which agent ran it, and what came back. For Tactiq, that is a record of which meeting an agent fetched and for which user. The connector keeps 90 days of history, exports to your SIEM, and separates failures by source.

Why it matters for meeting data

A security reviewer will ask which agent read the transcript of the leadership offsite, and on whose behalf. Without tool-level logs, the answer is a guess reconstructed from LLM traces.

Failure separation matters for debugging too. A Tactiq plan-gating error, a per-user rate limit, and a revoked grant look alike in agent output, but they have three different fixes. More on this pattern in agent tool observability.

Which one to build against

If your agent answers questions over meeting history, quotes what people said, or combines meeting context with other tools, build against Tactiq MCP. There is no REST alternative for on-demand queries, and the server's excerpts-first design rewards agents that search before they read.

If you need the same artifact after every meeting, or an event the moment a transcript is ready, Tactiq Workflows or the Zapier trigger are simpler and need no agent code. Many production designs pair them: a push event as the signal, an MCP agent as the reasoner.

Either way, every Tactiq user brings their own grant, plan, and scopes. That lifecycle is the part that needs production-grade infrastructure. For a deeper look at credential ownership across agent tool-calling patterns, see how different architectures handle token storage and delegation.

When moving from a single user to multiple tenants, the auth model changes significantly — per-user grants, scope isolation, and revocation all need to be designed explicitly.

Start building your Tactiq agent

Building a Tactiq agent for multiple users or tenants? Talk to us for immediate help with your auth and tool-scoping design.

To start on your own, read the Tactiq MCP connector docs, browse the Tactiq MCP connector, and check AgentKit pricing. Agent templates such as the sales call prep agent and the CRM AI agent show the same per-user pattern across meeting and CRM tools. Comparing meeting tools? Read Granola MCP vs Granola API for AI Agents.

No items found.
Agent
Auth Quickstart
On this page
Share this article
Agent
Auth Quickstart

Acquire enterprise customers with
‍zero upfront cost.

Every feature unlocked. No hidden fees.