The platform
Everything you need to build, run, and trust AI Actions.
A workspace for composing and operating AI Actions: typed steps, governed Apps and models, confidence gates on every agent, full execution traceability, and dataset-driven evaluation. Built so finance people can author the logic themselves, in plain language.
Step types
Eight building blocks. Any finance process.
Each step does one thing well. Outputs flow forward, while branching, iteration and errors get their own dedicated types. Pick a step to see what it looks like on the canvas, and what you control on it.
LLM reasoning with optional multi-turn tool use. Each step has a model, an agent role (versioned system prompt), assigned inputs, a whitelist of tools, a max-iteration cap, a confidence gate, and optionally structured JSON output validated against a schema.
You control
- Model per step
- Versioned agent role
- Tool whitelist
- Confidence gate
- Max iterations
- Structured output
Apps & tools
Approved endpoints. Reusable everywhere. Nothing else gets out.
Standard apps ship in the box; bring any OpenAPI in minutes, or connect a remote MCP server and use the tools it exposes. Endpoints become inputs and tools usable from Agent, Code and Tool Call steps, and from nowhere admins haven’t authorized. Sequence them with Loop Over for batch work, or fan them out with parallel Trigger Action calls; chained runs are tracked together as a cohesive work unit.
Standard apps in the box
Dooap, Microsoft Exchange, Azure Storage, Azure Communication Services: pre-built and admin-authorized, covering invoices, mailboxes, files, and outbound email & SMS out of the box.
Any OpenAPI as an App
Drop a spec, choose which endpoints become inputs and tools, and store credentials in the secret vault. Each App gets a toggleable inbound webhook.
Any remote MCP server
Connect a remote Model Context Protocol server and every tool it exposes becomes a governed Dooap Studio tool. The open MCP ecosystem, admin-authorized like everything else.
Tools shared across step types
The same endpoint works for an Agent step as a tool, for a Code step as a callable, or as a direct Tool Call. Wire once, use everywhere: deterministic and agentic side by side.
Pick the right model
The right model for each task.
Dooap Studio doesn’t lock you to one LLM. Each step picks its own model, and a specialist when determinism beats reasoning.
Multi-model per step
Pick OpenAI, Anthropic, or any configured model, independently for each agent step. Optimize cost or capability per task; switch in seconds.
Specialist models for specific jobs
An OCR model reads documents. Dense embeddings find similar invoices. Use the right tool, not just a bigger LLM, and stay deterministic where you need to be.
Output filters trim tokens
A JSONPath-like filter on every input and tool result keeps the prompt small. Faster answers, lower cost, less noise in execution logs.
Dooap Studio’s own data
Bring your data into Dooap Studio.
Sometimes the right place to keep state isn’t another system. It’s Dooap Studio itself. Two building blocks give Actions their own file system and typed tables.
Data Files
A per-tenant file system Actions can read from and write to. Drop a CSV, a JSON dataset, an exported document; reference it from any step.
data/ ├─ vendor-aliases.csv ├─ price-lists/ │ └─ 2026-Q2.json └─ exports/ └─ coding-report.md
Data Tables
Tables with typed columns Actions can search, write, and read. Keep reference data, lookups, or working state inside Dooap Studio, with no extra system to wire up.
| vendor text | gl_account text | credit_limit number | updated date |
|---|---|---|---|
| Nordic Freight Oy | 6210 | 40 000 | 2026-05-28 |
| Acme Industrial | 4010 | 125 000 | 2026-06-02 |
| Brightline Media | 4530 | 18 500 | 2026-06-09 |
The library
Start from a known-good pattern.
Don’t begin from a blank canvas. The Dooap Studio Library ships pre-made Actions, Apps, and Skills you can drop in and tailor.
Action templates
Common workflows like invoice intake, vendor matching, approval routing, and fraud checks, ready to clone, rename, and tailor to your data.
App templates
Pre-configured Apps with their endpoints already mapped as inputs and tools. Skip the wire-up; jump straight to composing.
Reusable Skills
Versioned instruction packs agents load by context. Write down how your team handles a job once, and every Action that needs it behaves consistently. Audit-logged like everything else.
Trust & safe rollout
The controls shipped software has — on your finance logic.
Versioning, dry-run on real data, dataset evaluations, and one-click rollback wrap every Action. Improve a live one, prove the change against captured runs, promote it — and roll back instantly if it misbehaves.
Confidence gates
Required Confidence Level per agent step — MED ≥60%, HIGH ≥85%. Below the bar the step is logged as confidence-not-met and fires its error Action: a human task, a fallback, or a stop. Pair it with a structured-output schema and a Code or Switch validation step so a deterministic check, not the model’s own score, gates the post.
Error Actions
Configure a dedicated Action to fire on failure. Recovery logic stays out of the happy path.
Versioning, end to end
Actions, Agent Roles, and Tools each carry their own auto-versioned history. One live version at a time; pin a step to a specific version when you need repeatable production behavior.
Promote and roll back
Make a draft live with one click. Roll back to any prior version instantly when something goes sideways.
Dry-run on live data
Execute the draft against real data with write tools stubbed, and see results before they commit.
Sandboxed code
Custom Code steps run with strict resource and throttling limits. No surprise side-effects.
Recorded live: a draft replayed against a test dataset of captured runs — three cases, field-level pass criteria, 100% before promotion.
Human in the loop
When AI can’t decide alone, it asks a human.
When a step lands below its confidence gate — or fails a validation check — the run pauses and the agent drafts a focused task for the right person: a colleague in Dooap Studio, or a vendor outside it via email and a one-time code. It cannot continue until the answer lands. It works the other way too: a human can kick off an Action through an agent-authored form.
Agent → human
The form is generated for this case: the exact field that matters, helper text, the document context, and validation. Not a template from a library.
Human → agent
People initiate Actions through agent-authored UIs; their answers arrive as structured inputs, and the agent validates and follows up live.
Anyone, anywhere
Dooap Studio users see their tasks in a Human Tasks tab. Outsiders get an email link with a one-time code, no account needed. Same audit trail either way.
Click to play the walkthrough — this clip has sound
A real execution, opened: resolved prompt, inputs, tool calls, confidence, step by step.
Observability & evaluation
See everything that ran. Improve what you saw.
Live Trigger Stream
A searchable feed of incoming triggers (source, context label, payload size, status), so you know what fired and where it went.
Per-run inspection
For every execution: the resolved prompt, inputs, reasoning, confidence, token usage, every tool call with its parameters and result, plus full provenance through chained Actions.
Searchable metadata
Metadata steps promote values into execution metadata so you can filter runs by invoice number, vendor, or any identifier you care about.
Evaluations & datasets
Promote real executions into reusable test cases. Run datasets to validate a prompt, tool, or model change before promotion.