Every run governed, costed, and audited. AI results, not AI chats!
IT staff, consultants, or MSPs author a prompt, script, or agent once, then
publish it as a service item their users can just run — close, reconciliation, AR aging, revenue reporting.
Users get results without touching prompts, credentials, or underlying systems: governed by default, costed
per run, multi-tenant from day one.
All through industry standard MCP servers.
Governed AI for a single growing back office — the fastest way to roll out reporting and operations with no internal AI team and no developers required.
Multi-team governance, isolation, and controls at scale for orgs with thousands of users across business units — and finance teams that need the spend to land in the right place.
Enables consultants, MSPs and accountants to build AI tooling across all client tenants from one place, with per-client isolation and control.
Built for the people who answer to auditors.
No developers required.
Every service item shares the same plumbing — MCP connectors, the run queue, input forms, live status, budgets, audit, downloadable output. They differ in who owns the control flow.
Plain English. The model acts as the agent — it orchestrates your connectors, works out the steps, and picks the best output format. Fastest to author; supports model tiers and batch.
# Prompt — the agent owns the plan List all active subscriptions grouped by product, with MRR per group, as an Excel sheet.
Full support for LSPL, executed in direct-execution mode — the AI reads each line
and acts on it,
reasoning at each AI.call, branching at each IF. Explicit and repeatable.
FUNC run(ticket) VALIDATE ticket.subject not empty DO c = AI.call("Classify this ticket") IF c.canResolve IS yes RETURN AI.call("Draft a reply") EMIT NeedsHuman { reason: "low conf." } RETURN "escalated"
Python in a secure sandbox for exact calculations and logic the AI shouldn't improvise. Call connectors
with mcp(...), reach for the model only where you want judgement, and emit(...).
rows = await mcp("Maxio").call( "advancedBillingShowCustomers", {"per_page": 20}) emit({"type": "excel", "sheets": [{"name": "Customers", "data": rows}]})
Prompt = "what I want," LSPL = "the steps to take," Script = "exactly how to do it." Whichever you pick, it publishes as the same one-click service item — same permissions, same budgets, same audit record. Don't want to start from scratch? Describe what you want and the portal generates a runnable script using the real tools your connectors expose — so tool names and parameters are correct, not guessed.
Declare a few inputs and one service item serves many cases. The user fills a short form up front; the values are validated, then woven into the run. No prompt editing, no guesswork.
{{key}}Reconcile account(s) {{accounts}} for the period {{period_start}} to {{period_end}}. Flag mismatches; return a status + comments. ## Inputs provided for this run - accounts: 1000, 1200, 2050 - period_start: 2026-05-01 - include_notes: true
Every value is also appended as a labelled block — a safety net so the model sees it even without a placeholder. Validated in the dialog and again on the server.
The builder / consumer split: the person who authors a capability is not the person who runs it. Build once; publish it as a service item; let everyone run it safely — governed, costed, and audited every time.
IT, consultants, and accountants build a prompt, agent, LSPL script, or Python — pick the connectors it may use, add inputs, set the output, set the budget. Save before you run, so what executes is the saved version.
# close_summary · type: lspl connectors: QuickBooks, Xero inputs: period (date) access: read-only budget: $0.25 / run costcenter: FIN-100 output: xlsx
Roles control who can see a service item versus who can run it. Publish to one workspace or every client tenant — and revoke or change it for everyone at once.
Fill the form, click Run, get a finished report. Every run is asynchronous, recorded in the audit log, costed to a cost center, and replayable — and notifies whoever needs it.
Build tools against deep domain knowledge, wire up connectors, add input forms, test, version, and publish — from one console.
No technical knowledge needed. Open My Reports, search the catalog, fill a short form, and click Run — a finished report comes back, every time.
Depth over breadth — back-office finance and operations done exceptionally well. Each workspace connects its own accounts over MCP; credentials are encrypted and never shared across tenants.
Read-only by default; write access granted explicitly, per connector. Roadmap: Microsoft 365, HubSpot, and more.
AI spend that finance can actually account for. Every run carries a budget before it starts and a cost after it ends — attributed to the user, the service item, and the cost center that asked for it.
| Cost center | GL account | Runs | Amount |
|---|---|---|---|
| FIN-100 · Accounting | 6820 | 412 | $318.40 |
| SLS-220 · Sales Ops | 6820 | 186 | $142.75 |
| OPS-310 · Supply Chain | 6825 | 97 | $74.10 |
| Total charged back | 695 | $535.25 | |
Model tiers and batch mode cut the bill before it's ever incurred: route simple jobs to a fast model, run non-urgent work in batch at roughly half the cost.
Built for the people who answer to auditors — the reason to choose a governed portal over handing staff raw ChatGPT or Claude logins.
Grant View and Run precisely, per AI tool. Invite users by email with optional approval, assign roles, and publish a capability to exactly the right people.
Who ran what against which data, every connector call, every admin change — all recorded, with the cost and cost center on every line. You always know who did what, and what it cost.
Connectors are read-only out of the box. Write access is granted explicitly, per connector — a tool can never change data through a connector that isn't write-enabled.
Python runs in an isolated sandbox with no access to platform secrets. A trusted broker injects credentials per call and tears them down when the run ends — tools never hold your keys.
Every workspace's data, connectors, tools, and results are isolated at the database level and never cross into another — the same guarantee that powers the channel model.
Per-run token and call budgets with fail-closed enforcement, so a runaway job can't loop forever or run up a bill. Spend lands on a cost center; only approved models can be used.
Build a capability once against your systems of record. Publish it as a service item to exactly the right people. One click and they get a finished report back.
Add a short form to any service item — Text, Number, Yes/No, Date, or Dropdown. Users pick a date range or an account and click Run. Inputs are validated before the run ever starts.
NetSuite, Salesforce, Maxio, QuickBooks Online, Xero, and Google Drive over the Model Context Protocol. Each workspace connects its own accounts — credentials never cross tenants.
Excel (multi-tab, searchable), formatted HTML, print-ready PDF, charts, plain text, or JSON. Record IDs link straight back to the source system; download with one click.
Run on demand, or automatically — daily, weekly, or monthly in the timezone you choose. Scheduled runs land in History with a badge and notify the right people.
Runs are asynchronous: Queued → Running → Ready (or Failed). Status follows you across the app. History keeps every run's inputs, result, and cost — re-open, re-run, or cancel.
Share a finished report through a secure link that opens an access-controlled viewer — never a raw file. Optional email notifications fire when a run finishes or fails.
See how Netridium publishes your prompts, scripts, and agents as governed service items your whole team can run — costed and audited on every run. Tell us a bit about you and we'll be in touch.