See Exactly What Your Agents Can Reach
One Page That Answers Whether Anything Is Wrong
Dashboard is the administrative landing view and it carries six tabs: MCP, API Gateway, Health, Indexing, Events, and Notifications. The first of them opens on tool-call activity across a window you choose, from the last hour out to seven days. What fills the last of them, and where an admin points outbound mail, is covered on Notifications.
Volume, Success, and the Rhythm of a Working Week
Why it matters
Adoption questions and incident questions look identical from the outside. Both start with how much is being asked, by whom, and whether it is succeeding.
How it works
Summary cards report total calls, success rate, average duration, unique users, unique tools, enrichment rate, and errors, each with its trend against the prior window. An activity timeline charts call volume with errors overlaid, and a usage-rhythm heatmap lays the last seven days out by weekday and hour, which is where a nightly job or an abandoned Friday afternoon becomes obvious. Below that sit top tools and top users, response-time percentiles, a clickable recent-errors list, the knowledge review queue, and every connected backend with its tool count.


Every Call, With the Arguments It Was Made With
Why it matters
When something goes wrong you need the exact call, its arguments, its response, the persona that allowed it, and the session it belonged to. A sanitized summary answers none of that.
How it works
The Events tab indexes every tool invocation, filterable by user, tool, status, and time, with sortable columns and CSV or JSON export. Any row opens a detail drawer carrying identity (user, persona, session), execution (tool, connection, duration), status and enrichment, transport sizes, and the full request parameters as JSON. Distributed tracing follows one request through sign-in, context gathering, and the underlying data call.


Which Node Is the Problem
Why it matters
Incident response starts with knowing whether the stack is degraded and which node is degrading it, before anyone starts guessing.
How it works
The Health tab reports per-node uptime, CPU, resident memory, heap, and goroutine counts across the fleet, with a clear status for each and a dash wherever a metric is genuinely missing rather than a zero that reads as healthy.


Watch Semantic Ranking Stay Healthy
Why it matters
Embedding work runs off the request path, so a slow provider or a run of retries degrades ranking toward keyword-only with nothing but a log line to say so. Search quietly gets worse and nobody is told.
How it works
The Indexing tab reports the embedding provider, model, and dimension, then a plain verdict per corpus: up to date, indexing, or degraded, each with real indexed-of-expected coverage and when it last ran. Equivalent states look identical, so a healthy corpus is recognisable at a glance rather than read. Below sit a throughput timeline, embed latency at the median with a 95th-percentile marker, in-flight jobs with their lease countdown and progress, retry backoff with attempt counts, and open failures grouped by error signature. A failure resolves itself and leaves the panel once a later job for the same unit succeeds. Re-index re-enqueues everything out of sync for a corpus.


Did the Email Actually Arrive
Why it matters
A share that never reached its recipient looks exactly like a share nobody opened. Without a delivery read, the first sign of trouble is somebody saying they never got it.
How it works
Counts by status sit above the list, failed, pending, sending, and sent, and each doubles as a filter. Every row shows when it was raised, who it was addressed to, the subject the message carried, its category, its status, and how many attempts were made. Opening a row exists for the failure case: it shows the error the mail server returned, verbatim, alongside the attempt count before the queue gave up. Filters narrow by recipient, status, and category. It holds recent history rather than an archive, and the window it covers is stated above the list.


Teach Every Session the Same Thing
Agent Instructions is the operating guidance every agent session receives before it does anything. It is the highest-leverage screen in the administrative half, because it is the one place a rule reaches every conversation without anyone repeating it.
Your Context on Top of the Platform Baseline
Why it matters
Guidance that lives in somebody’s head gets applied on the sessions they are watching. Written once and served to every session, it applies on the ones nobody is watching.
How it works
A split markdown editor puts source on the left and live preview on the right. Above it sits the read-only platform baseline: the platform-owned guidance composed beneath your own, naming only the tools this installation actually exposes, so you can see what is already covered and add only your business context on top rather than restating it. Every change made through the administrative sections is recorded with who made it and when, so the guidance has a history rather than a current value.


Turn Whole REST APIs Into Governed Tools
An agent can call any external REST or HTTP API by reading that API’s own OpenAPI description to learn its operations and inputs, then signing in and calling it under per-role rules. Ten APIs do not add a thousand tools, and every call rides the same audit pipeline as native data access. Read the API Gateway page.
One Spec, Every Connection That Points at It
Why it matters
Generating one tool per endpoint explodes the catalog: ten APIs would add a thousand tools an agent has to sort through, which wrecks tool selection long before it wrecks anything else.
How it works
A catalog is a versioned bundle of OpenAPI specs that many connections share, so one upload documents every connection pointing at that vendor. Specs are ingested by paste, file upload, or a public URL fetched once. The whole surface is then served through four tools: browse the spec sections, list a section’s operations, read one operation’s exact schema, and invoke it. Each spec carries an embedding-health badge and a last-fetched time, with refresh, retry, edit, and delete beside it, and a catalog cannot be deleted while a connection still references it. Large or binary responses stream straight to an asset instead of into the answer.


Watch Where the Outbound Calls Go
Why it matters
Outbound traffic is the part of an integration nobody watches until a vendor rate-limits you or an endpoint starts failing quietly.
How it works
The Dashboard’s API Gateway tab charts connection-to-operation traffic as a flow, with an inbound-versus-outbound health split by status category and breakdowns by status class, method, and calling identity. Every endpoint is semantically indexed, so operations rank by what they mean rather than by name matching, and a plain REST route exposes the same connectors to clients that are not agents at all.


Everything Produced, Across Everyone
The administrative Assets view is the platform-wide read of what agents have produced: every asset from every user, with the provenance that says where each number came from.
What Was Produced, and Who Produced It
Why it matters
A workspace nobody can see across is a workspace where the same report gets built four times and no one notices the fourth is wrong.
How it works
The table lists every asset on the platform with its name, owner, content type, file size, sharing state, and creation date, searchable and filterable by type, owner, and connection.


Where a Number Actually Came From
Why it matters
An artifact without lineage is a claim you cannot check. When a figure is disputed, the argument only ends when somebody can point at the query.
How it works
Asset detail renders the content in the same full viewer users get, alongside the originating session, the tool calls that produced it, the datasets those calls touched, and the full version history. Delete, download, and share are available from the same screen.


Every Endpoint on One Page
The Automations section of Admin lists every automation across every owner, and its Endpoints tab lists every automation published at its own address, so an admin can see what answers requests from outside without opening automations one at a time. Read the Forms and Endpoints page.
Who Calls It, How Often, and What Was Refused
Why it matters
An automation that answers requests is a door into your data. Whoever is responsible for it needs to see who comes through it and who was turned away, without reading logs.
How it works
Each endpoint lists its automation and owner, its access mode, whether it is on, and over the last day or week its requests, failures, refusals, slowest responses, and last request. Opening one charts its traffic, names the reasons requests were refused before the automation ran, lists its busiest callers, and turns it on or off. Only an admin publishes an automation at an address or takes it down.
Each endpoint has one access mode
- Authenticated
- Named roles or API keys. A partner system calls with its key.
- Bot check
- Anyone who passes the check: proof of work, Turnstile, or hCaptcha.
- Public
- Anyone, with no check, and marked as public everywhere it appears.
Every mode also carries rate limits per endpoint and per caller.
Keep the Catalog in Step With Every Connection
Plexara catalogs every database, API, and GraphQL connection on its own, and the Catalog section of Admin is where an admin watches that happen. Curation itself happens under Knowledge, where the people who know the data work.
What Was Read, What Changed, and What Could Not Be Read
Why it matters
A catalog that silently stops picking up new tables is worse than none, because people trust it. The admin needs to see each connection’s last pass and anything it skipped.
How it works
Each connection shows its last scan, when it finished, how many datasets it wrote and marked as no longer present, and any part it could not read, with the reason. Scan now runs one on demand. A dataset that disappears keeps its curation, and comes back with it if the table returns. Scans never touch descriptions, tags, or glossary terms people wrote.


Every Backend, Including Other MCP Servers
Connections manages the systems the platform reaches: Trino, object storage, REST and GraphQL APIs, and other MCP servers. A search box and a kind filter narrow a long list as you type. A gateway connection proxies an upstream MCP server and re-exposes its tools as native ones, under the same persona rules, audit trail, and enrichment as everything else.
Upstream Tools Under One Access Model
Why it matters
Every MCP server a team adopts is another endpoint, another sign-in, another silo. Agents end up juggling connections instead of getting one coherent surface.
How it works
A split-pane list groups connections by kind with their descriptions and tool counts; selecting one shows its metadata, its configuration with a show-sensitive toggle for credentials, and its actions. A gateway connection re-exposes an upstream server’s tools under a local prefix so they sit alongside native tools and obey the same rules. Test connection dials the upstream with the values on screen, before anything is saved, and reports whether tool discovery succeeded. Refresh tools re-reads a saved upstream and re-registers its catalog live, so every connected agent’s tool list updates without anyone reconnecting.


Sign In the Way Each Upstream Demands
Why it matters
Real upstreams authenticate in incompatible ways, and some hosted vendor servers require a human browser sign-in rather than a static token, which is exactly the case a scripted integration cannot cover.
How it works
Connections support bearer tokens, API keys, HTTP basic, OAuth 2.1 with either machine-to-machine credentials or browser sign-in with PKCE, and client-certificate mTLS. Two more modes cover the systems those cannot: a connection can sign every outgoing request so a receiver that verifies signatures knows it came from Plexara, and it can sign in to a system that issues session tokens (Tableau, MicroStrategy, Veeva Vault), share that session across calls, and sign in again when the session ends. A browser sign-in connection shows a not-connected banner with a Connect button; authorizing opens the upstream’s own sign-in, and the card then names who authorized it and when. Tokens and secrets are encrypted at rest, access tokens refresh silently so scheduled work keeps running, and a certificate’s expiry surfaces as a badge before it bites.


Receivers Know the Request Came From You
Why it matters
A system that accepts events from outside has to know who sent them. Receivers built for Stripe, GitHub, or Standard Webhooks check a signature on every request and refuse anything unsigned.
How it works
An API connection set to sign its requests holds the signing secret, encrypted and never shown again, and picks a preset for the receiver it talks to, or sets the signature’s parts one by one. Every call through the connection is signed, including deliveries from a notification channel that sends through it, so an automation posting to another system never handles the secret.


Reach Systems That Issue Session Tokens
Why it matters
Some business systems never accept a standing key. They take a sign-in, hand back a session token, and expect it on every call until it runs out.
How it works
A connection set to session sign-in names where it signs in, the body it sends with the secret in place, where the token comes back, and the header it travels in. The platform signs in once, shares the session across every call, and signs in again when the upstream says the session has ended.


Never Overwhelm a Fragile Upstream
Why it matters
Some vendor APIs answer one request at a time and fail in strange ways when two arrive together. The agent, a dozen automations, and a person in the portal do not know about each other.
How it works
An API or GraphQL connection can carry a limit on how many calls run against it at once. Every caller waits its turn for a slot, the agent and every automation alike, and the limit is shown to the agent before it fans out a batch of calls that would only queue behind each other.
One connection, limit of one call at a time
- The agentrunning
- Nightly syncwaiting
- Order lookupwaiting
- A portal runwaiting
Vendor API
Sees one request at a time
Give a Third-Party Tool Your Warehouse Context
Why it matters
One source’s response carrying another’s context is the whole point, and it should apply to proxied third-party tools too. Hard-coding that per tool does not scale past the second one.
How it works
A rule attaches warehouse and catalog context to a proxied tool’s response without any code: a predicate that fires always or when the response contains a value, a source operation against the catalog or Trino, bindings that pull from the call’s arguments, the response, and the caller, and a merge strategy that decides where the context lands. A dry run pastes in a sample call and returns the merged response with no side effects. A rule that fails attaches a warning rather than failing the call it was enriching. Rules are managed from a drawer on the gateway connection and shown on the tool itself.


What the Platform Says It Is
Description sets the identity the platform reports to connected clients. It is the first thing an agent reads about what it has just connected to, and the sentence that decides whether it uses the platform well.
The First Thing an Agent Learns
Why it matters
An agent that does not know what a platform is for will use it like a generic database. A description that names the domain, the data, and the intended use changes the questions it asks.
How it works
The same split markdown editor as Agent Instructions, source beside live preview. What you write is surfaced to connected clients as the platform’s identity, and, like the instructions, every edit is recorded with its author and time.


Credentials for the Things That Are Not People
Keys mints credentials for programmatic callers: a scheduler, a pipeline, a script, anything that needs the platform without a human at a browser.
Scoped, Expiring, and Shown Exactly Once
Why it matters
A service credential with no scope and no expiry is a credential that outlives the project it was minted for and grants more than that project ever needed.
How it works
Each key is created with a name, an optional owner and description, its roles chosen from a browser, and an expiration preset from a day out to a year or never. The generated key appears once in a copy-now banner and never again. The table lists every key with its roles, owner, and expiry, dims expired ones with a badge, and revocation takes effect immediately.


Fail-Closed Access, Defined by Role
A persona maps the roles your identity provider already issues to exactly the tools and connections that role may reach. It is default-deny: what a persona does not allow is not merely refused, it is never shown to the agent at all.
What a Role Can Reach, and Nothing Else
Why it matters
Access defined as a pile of low-level permissions drifts from what the business actually meant, and anything not explicitly denied tends to leak. Roles should get what they need and nothing adjacent to it.
How it works
A persona carries allow and deny tool patterns, a connection allowlist, a priority, and the identity-provider roles it maps to. Because unauthorized tools are invisible rather than blocked, an agent never spends tokens reasoning about capabilities it cannot use, and access is refused before a request reaches the data layer. Context overrides tune behaviour per role with a description prefix and an agent-instruction suffix, so the same tool can be introduced differently to an analyst and to an engineer.


See What the Rule Resolves To Before You Save It
Why it matters
A pattern that looks right and resolves wrong is the whole risk of pattern-based access. Finding out after the fact means finding out from an incident.
How it works
One page of sections, grouped by the surface each governs: identity and account type (internal people, external people, or an automated caller), the AI assistant’s tools, connections, API endpoints, and instructions, and portal access with one level per portal area. Every tool and connection row shows the server’s decision with Allow, No rule, and Deny beside it, and a deny pattern still wins. An access summary, computed by the server from the page as it stands, saved or not, shows what the persona reaches before anything is saved.


The Library, From the Other Side
The administrative Prompts page manages every prompt at every scope, and it is where a personal prompt someone wrote becomes something their team, or the whole organization, is served.
Global, Persona, Personal, and System in One Table
Why it matters
Prompt quality drifts where nobody is looking. Seeing every scope in one sortable table is what makes a stale global prompt findable before somebody runs it.
How it works
A sortable table lists every prompt with a scope badge, a lifecycle badge, its owner, category, and tags, filtered by scope and searched across name and description. Editing exposes the lifecycle selector that moves a prompt from draft to approved to deprecated or superseded, stamping the approving admin; choosing superseded reveals a field for the replacement prompt’s name, so a retired prompt says what took its place.


Someone’s Prompt Becomes the Team’s
Why it matters
The prompts worth standardizing are the ones already being used, and their authors are rarely admins. Without a request path, good work stays personal.
How it works
A panel at the top of the page lists the personal prompts whose owners have asked for promotion, naming the owner, the scope requested, and the description; it is hidden entirely when nothing is pending. Approve applies the requested scope and marks the prompt approved, reject clears the request and leaves it personal, and a name that already exists at the target scope blocks approval as a conflict so the owner renames first. A prompt an admin creates at a shared scope lands approved with that admin stamped as approver, since the creator is the reviewer.


The Reference Library, Across Every Scope
The administrative Resources view is every uploaded file in one place, across every persona and scope, which is what makes curating the library possible rather than aspirational.
Find What Nothing Has Read
Why it matters
A reference library only decays in one direction. Material accumulates, nobody removes anything, and agents start pattern-matching against a template that was replaced a year ago.
How it works
The same file manager users get, opened across every scope: the folder tree holds global material, each persona’s folders, and each person’s, with search across them. The listing adds a Last read column, so the library can be ordered by what is actually used, and a resource never read since it was uploaded over thirty days ago is flagged. An admin can open, edit, and delete any resource, including persona material they do not belong to, while listing and agent-facing reads stay scoped to membership.


Vendor Credentials Nobody Has to Paste
Secrets holds the passwords, API keys, and authenticator seeds that connections and automations need but should never see. A value is written once and never shown again.
Used by Name, Never Seen
Why it matters
A key pasted into a script or a connection field ends up in version history, logs, and screenshots. Rotating it then means finding every copy.
How it works
Each secret is write-only and encrypted, limited to the connections and roles that may use it. A connection or an automation names it, and the value is filled in only as each request leaves Plexara. It never appears in a script, a run, a recorded call, or an audit row. For vendor portals that require a one-time code, a secret can hold the authenticator seed, and the current code is filled the same way. Google service account keys are stored here too. Rotate a secret once and every connection that uses it picks up the new value.
Where a secret goes
01
Stored
Write-only and encrypted, limited to named connections and roles
02
Named
A connection or automation refers to it by name, never by value
03
Filled
The value is put in as the request leaves Plexara
04
Kept out
Never in a script, a run, a recorded call, or an audit row
Delivery, Alerts, and Access, One Section at a Time
Settings holds the deployment-wide choices your admins own, grouped by topic, each section with its own address so a link opens it directly. The navigation flags a section that needs attention, such as a channel whose last delivery failed.
Where Messages Go, and Who Hears About Problems
Why it matters
Every alert is only as good as the place it lands. One screen for mail, channels, and alert routing keeps that decision in one set of hands.
How it works
Delivery sets the outbound mail server, with a test send, and the notification channels: Slack, Mattermost, webhooks, and email lists. Alerts route the review-queue reminder, revoked connection sign-ins, failing automations, and webhook problems to the channels you choose. Maps sets the regions the street maps in reports cover. Bot checks names the checks a public form or endpoint can require. Access requests sets how long a request for access stays open.
Admin > Settings
Delivery
- Channels
Alerts
- Knowledge review
- Connection revocations
- Run failures
- Webhooks
Content
- Maps
Endpoints
- Bot checks
Access
- Access requests
Every Tool, Typed, Testable, and Attributed
Tools is a master-detail view of everything the platform exposes, grouped by the connection that provides it. A tool you cannot inspect is a tool you cannot govern, so each one opens onto its schema, its access rules, an execution surface, and its own usage.
The Schema and the Rule That Decided Access
Why it matters
Knowing that a role cannot call a tool is half an answer. The useful half is which rule decided it, because that is the part you can change.
How it works
The overview shows a tool’s description with an inline override editor, the connection it belongs to, its full JSON input schema, and per-persona access: which personas can call it and the exact pattern that resolved to that verdict. An adjacent activity view aggregates the tool’s own call volume, success rate, and average duration, with a deep link into the audit log filtered to it.


Run the Tool Yourself Instead of Asking an Agent To
Why it matters
Debugging a tool by asking an assistant to call it puts a language model between you and the answer. You want the raw call and the raw response.
How it works
Try It generates a form from the tool’s schema with type-appropriate inputs, a text area for a query, a number field for a limit, a dropdown for an enum, runs it against the live source, and renders the result as a formatted table with a raw toggle. A timestamped history keeps every test call with its duration and status, and any of them replays.


Check the Blast Radius Before You Commit
Why it matters
Turning a tool off platform-wide is the kind of change that is obvious in hindsight and surprising in the moment, because the person making it rarely knows every persona it touches.
How it works
Visibility toggles a tool’s membership in the platform-wide deny list and previews whether a given persona can still reach it, before the change is applied.


A Directory So Sharing Knows Your Colleagues
Users is a directory of people, not an authorization layer. It grants nothing on its own; it exists so the share picker can suggest a colleague by name instead of asking somebody to remember an address.
Suggest the Person Before They Have Signed In
Why it matters
Sharing fails on the small stuff. A mistyped address sends work to nobody, and a new hire who has not logged in yet cannot be picked at all.
How it works
Anyone who authenticates is recorded automatically with the name from their sign-in. An admin can pre-add someone by email so they are selectable for sharing before their first login, where they show as invited rather than active. Admin-entered names take precedence: a later sign-in fills blank fields but never overwrites a name someone set deliberately. The table lists name, email, status, and last seen, with search across it.


Events Other Systems Send, on One Screen
Webhooks is where an admin on your team points another system’s webhooks at Plexara, or connects a mailbox for Plexara to read. Each source is one sender, a CRM, a point of sale, a mailbox of vendor notices, and each one lands as a table your agents and automations query like any other. Read the Webhooks page.
Is It Arriving, and Is Anything Being Refused
Why it matters
A sender that stops produces no error on the receiving side. The only way to notice is a screen that says when each source last heard from its sender.
How it works
The page charts requests by outcome for the last hour or the last day, for every source or one. Below it, one row per source gives its health (receiving, silent, failing, or disabled), when it last received an event, what was accepted and rejected over the last hour and day, and whether any of what it received is failing to be kept. Recent rejections lists every refused request with its source, time, outcome, and reason, and never its body. New source creates one, with the proof each sender must present to be accepted.


Every Source Is a Table to Query
Why it matters
Events are only useful once someone can ask questions of them. A feed that has to be exported and loaded first is a feed nobody reads.
How it works
Each source’s table is listed in Scratch Tables beside the spreadsheets people have registered. Its page gives a ready query for today’s events, the columns every event carries (when it arrived, its id, its type, its key, and the payload as sent), and a link back to the source it comes from.


Next
MCP Security
The threat model behind the audit trail: what a governed MCP endpoint has to defend against.

