CAMERON WESTLAND

My Corner of the Web

When the API Barrier Vanishes

Date:

How MCP‑style LLM Wrappers Unlock the Integrations We Always Wanted

TL;DR — When LLM-powered agents can plan and call REST APIs for you, the activation energy for integrations collapses. MCP sticks to plain JSON + standard auth while the model handles schemas, retries, and pagination—ideas that once took weeks of Zapier flows now fit in a single prompt.

My brother—a twenty-year IT veteran on sabbatical—pinged me last week:

“I just pointed the Jira MCP server at our board. The agent grabbed a ticket, set it to In Progress, did the work, marked it Done, pushed to GitLab, and opened a PR.”

He'd never touched the Jira API before—too many docs and too much OAuth. One evening with Atlassian's MCP server plus an LLM erased the friction. The activation-energy line plummeted, and years of "someday" automations popped into reach.

Why Integrations Stall

Most teams flirt with Zapier, maybe write a weekend script, then hit the wall:

  • Doc fatigue. API references longer than War & Peace.
  • Auth pain. PATs, scopes, secret rotation.
  • Schema mapping. Column A → custom12345 in Jira.

The Old Work‑Arounds

  1. Pray for an official plugin. Slack‑to‑Jira, Jira‑to‑GitLab—nice when it exists, useless for edge‑cases.
  2. Roll our own. Spin up a service, read the docs, babysit cron jobs.

Either way the original developer—the SaaS vendor or your crew—had to predict every future use‑case. MCP sits in the middle: the vendor publishes a manifest once and anyone can talk to the agent in plain English. Long‑tail ideas that never justified a sprint are now a chat prompt away.

What MCP Adds (in 60 Words)

A JSON manifest describes each API call. A secure sandbox lets an LLM plan and execute those calls. You keep vanilla REST—no new protocol—while the model handles auth, pagination, and retries. Users stay in domain language(“extend the Q3 roadmap”) and never think about endpoints.

Jira MCP in the Wild

  • Issue triage: The agent scans the board for tickets assigned to a developer.
  • Auto‑assignment: It re‑assigns the ticket to itself and flips the status to In Progress.
  • Do the work: Runs the required script or code to complete the task.
  • Commit & PR: Pushes to Git/GitLab and opens a pull request.
  • (Planned) Review: Hands the PR to an AI code‑reviewer and, if approved, merges.

A workflow that once needed a backend service, two webhooks, and a cron job = one prompt + one manifest.

Sidebar: Zapier vs. MCP

Zapier / IFTTT

  • You think in app verbs: “When Google Sheets → New Row, then Jira → Create Issue.”
  • Flows are linear and one‑directional.
  • Schema is locked the moment you build the zap.
  • Rock‑solid guardrails, but limited flexibility.

MCP Agent

  • You think in domain intent: “Add a mobile‑login epic to the Q3 roadmap.”
  • The agent can plan multi‑step, looping workflows to hit a goal.
  • It introspects the API schema at runtime, so new fields are discovered automatically.
  • Requires validation and rate‑limit policies, but unlocks far broader scope.

Bottom line: Zapier automates at the app level; MCP automates at the intent level.

If Zapier is a single-app dashboard, ERP suites are the walled-garden edition—monolithic, pricey, and supposedly integrated. MCP makes that moat look suddenly shallow.

Why ERP Lock‑In Looks Weaker

For years the safest way to keep data consistent was to buy everything from one giant suite—run finance, supply‑chain, and HR inside SAP and let their internal plumbing handle the joins. That convenience carried a hefty price‑tag.

Once an agent can stitch best‑of‑breed apps together on demand, the risk of a mixed stack plummets. The value prop of “everyone in the same sandbox” shrinks right alongside it. Suites won’t vanish, but the premium they charge for integration feels a lot less defensible.

Reality Check

MCP isn’t magic. First‑time OAuth still needs a human click. A hallucinated payload can torch prod data. Unbounded loops will spike your API bill. The game shifts from building integrations to governing them—think schema validators, rate‑limit policies, and audit logs. Nail those, and the upside dwarfs the risk.

Surfacing the Latent Demand

The Jira anecdote is a glimpse of pent‑up automation that lived just below the friction line for years. MCP drags that line down, and suddenly:

  • PMs speak in roadmaps, not spreadsheets.
  • Founders stop yak‑shaving OAuth flows.
  • Even ex‑EVPs uncover a pile of quick wins.

Next step: scan your own backlog of “would‑be‑nice” automations, pick one, and wrap it in MCP. Odds are the effort line has finally dropped—and your motivation is enough.