Plexara
The oldest gap in analytics
An analyst finds twelve thousand lapsed members whose giving history says they would respond to a renewal appeal. That is a good morning’s work, and in most organizations it is also where the work stops. The finding goes into a deck. The segment has to reach the email platform, which means an export, a ticket, a colleague with the right login, and a send that happens a week later against a list that has already drifted.
Business intelligence has lived with this gap for forty years. The systems that hold the answers are read-only by design, and the systems that take the actions belong to other teams. Every insight pays a toll in handoffs, and the toll is measured in days.
The interesting property of an agent connected over MCP is that the gap is no longer structural. An agent that can query the warehouse can, through the same platform, call the systems where actions happen. The question stops being whether the loop can close and becomes whether it can close safely.
The last mile of an analysis
Analysis, then a handoff
The finding stops at a report
- The agent identifies the audience and writes it up
- Someone exports a CSV and uploads it into the campaign tool
- The send happens days later, against a list that has already drifted
- No record connects the action back to the analysis that justified it
Analysis, then the action
The finding carries its action
- The same session pushes the audience through the sync it found
- The campaign is scheduled through the same governed surface
- Every call is recorded with who made it, what it did, and why
- Delivery numbers come back the next morning for verification
One surface, three kinds of truth
Plexara’s API gateway makes any service that describes itself with an OpenAPI document part of the platform: registered as a connection, its operations cataloged, searchable, and callable through a handful of fixed agent tools. We have written before about what that does for seeing across the stack. The part that changes daily work is that the same surface carries writes.
That puts three kinds of truth in one place. The warehouse holds what happened: transactions, memberships, viewership, settled payments. The catalog and knowledge graph hold what it means: definitions, lineage, and the corrections a team has accumulated. And the gateway holds what is true right now at the edges, in the systems the data came from and the systems where the next action lands.
Production deployments show the range. One connects a fundraising CRM with 577 operations, an email engagement platform, a reverse-ETL service, a social analytics API, an event guest-list system, and the pipeline and cluster infrastructure underneath. Another connects payment settlement reporting, seven public data services, and its own monitoring stack. The agent discovers the operation it needs by intent, ranked by meaning as well as keywords, and pulls the request schema only when it is about to call.
Reading the edges
Most gateway traffic is reads, and the reads alone justify the connection. The warehouse’s copy of a constituent is hours old; the CRM’s copy is the ground truth, one call away. The settlement processor’s view of yesterday’s card batches either reconciles with the warehouse or it does not, and an agent that can query both sides finds out in one session. When a number looks wrong, the agent checks the pipeline that loaded it and the cluster that pipeline runs on before anyone writes an incident ticket.
Responses do not have to squeeze through the model to be useful. A large result streams directly into the portal as a saved asset, up to a hundred megabytes, where it can be queried with SQL beside the warehouse and cited by the analysis it feeds. The gateway also surfaces pagination rather than pretending an API returned everything, so a truncated read announces itself instead of becoming a silently wrong total.
Acting on them
Now the morning’s finding again. The twelve thousand lapsed members exist as a query result. On the same surface, the agent triggers the reverse-ETL sync that pushes the segment to the email platform, schedules the renewal campaign there, and comes back the next day to read the delivery and open numbers from the engagement platform’s own reporting. One session, one audit trail, no exports.
The same shape recurs across operations. The ingestion flow that quietly stopped gets its run state changed instead of a ticket. The guest list for Thursday’s event gets updated in the events system the moment the RSVP report reveals the mistake. Each of these was always one API call; what was missing was a governed way to let the system that found the problem make the call.
This is where research, business intelligence, and operations stop being three tools. The agent that correlates public demographics with sales is the same agent that reads pipeline health and the same agent that pushes the corrected audience, and every one of those acts draws on the same accumulated knowledge of what the data means. At production scale that traffic is substantial, and the portal renders it as an operational surface of its own.
What makes acting safe
Letting an agent write to production systems is a governance question before it is a capability question, and the gateway answers it structurally. Access is closed by default: a persona sees only the connections it was granted, and within a connection, policy allows or denies each method and path. Read everything, trigger one specific sync, create nothing: that sentence is expressible as policy, and the operations outside it are invisible to the agent rather than merely refused.
Credentials never enter the loop. The platform holds each connection’s authentication, from rotating OAuth tokens to client certificates, and applies it server-side when a call is made. The agent works with operations and intents; it has nothing to leak.
And every call is on the record. Each invocation writes an audit event with the acting user, the operation, the stated purpose, and the outcome, reviewable in the portal’s activity views alongside queries and knowledge changes. Execution-time governance is what makes the difference between an agent that could act and an agent a team lets act.
Permission at the grain of a route
Marketing analyst persona · campaign connection
- GET/api/campaigns/**allowed
- GET/api/v1/syncs/**allowed
- POST/api/v1/syncs/*/triggerallowed
- POST/api/campaigns/createdenied
- DELETE/api/**denied
- every route not matched abovedenied by default
The platform claim
Assembled, this is a different product category than an AI assistant that answers questions. A question-answering system ends at a finding. A platform whose agents read the warehouse, consult the knowledge graph, reach the ground truth at the edges, and act on the systems that need changing is a working surface for research, business intelligence, and operations at once, with each activity strengthening the context the others run on.
The gap between finding and doing was never a law of nature. It was an artifact of systems that could not safely share a surface, and a governed API gateway is what retires it. The full picture of what connects today is on the integrations page, and the governance model shows the policy grain that makes acting defensible.