Features
Everything Phorma Agent Studio actually does
A visual workspace for multi-agent workflows, from the canvas and the live debugger through evals, Portal and one-click deploy. Twenty sections, only shipped work, plus an honest note on what is not built yet.
01 · The canvas
The canvas is the source of truth
One infinite surface your whole team can read, fast enough to hold a real system.
Agents, triggers, tools and flow nodes are draggable primitives on an infinite, zoomable Canvas2D surface rather than DOM node soup, so it holds 60fps with hundreds of nodes on screen. Handoff edges carry control flow and dashed tool-link edges declare exactly what an agent is allowed to call, so the shape of a system is legible at a glance. Minimap, multi-select, undo and redo, clipboard and a command palette make it behave like a real design tool. The canvas is not a diagram kept beside the implementation. It is the implementation.
60fps with hundreds of nodes
Canvas2D rendering, not a tree of DOM nodes
Two kinds of edge
Handoff edges for control flow, dashed tool links for permissions
Built like a design tool
Minimap, multi-select, undo and redo, clipboard, command palette
02 · Live runs
Watch your agents think
Execution theatre on the canvas, so anyone on the team can see what the system is doing.
When a run starts, the graph comes alive. Nodes glow while they are thinking, handoff edges pulse as control moves between agents, and tokens stream into place as they arrive. Thinking overlays put reasoning next to the node that produced it, in context, instead of burying it in a log file. A product manager or a support lead can watch a run and follow it without reading a stack trace, which is usually the difference between a workflow one person owns and a workflow a team trusts.
Live run
triage-agent
streaming
crm-lookup
tool call
escalation-agent
thinking
03 · Debugger
A debugger, not a log tail
Pause, step and inspect a live run the way an IDE treats code.
Set breakpoints on any node, pause a run mid-flight, step it forward one node at a time, then resume. Inspect the exact payload handed between agents so you can see where an instruction was dropped instead of inferring it from the final answer. Human-in-the-loop nodes work the same way: Approval Gate and Ask User pause the run for a real decision and resume from where they left off, which is what makes an agent workflow safe to put in front of a process that matters.
Breakpoints and pause
On any node, on a live run, local or deployed
Step and resume
Advance one node at a time and watch the payload change
Human in the loop
Approval Gate and Ask User pause for a decision, then continue
04 · Run history
Every run is kept, and every run is replayable
Nothing you have run disappears, whether it ran on your machine or in the cloud.
Local and cloud runs are persisted with their inputs, per-node output, full trace, status and trigger source, so you can answer what happened at 3am without reproducing it. Browse past runs and bring one back onto the canvas to read it exactly as it executed. You can also attach live to an in-flight cloud run that a webhook or a cron started: completed nodes are restored and the current node pulses, so a production run reads identically to one you started yourself.
Run history
cron · 06:00 daily
completed
webhook · orders
running
manual · local
completed
05 · Cost and usage
Cost you can defend before you deploy
Answer what a workflow costs per run, per node and per model, with real numbers.
Token and cost accounting is recorded for every run and broken down per node and per model, using a synced provider pricing table so every provider reports a cost and anything estimated is clearly labelled as an estimate. A durable usage ledger backs charts over time inside the Studio, so an ops owner sees a trend rather than a surprise invoice. That turns the decision to deploy from an act of faith into a number someone can sign off.
Per run, per node, per model
See exactly which agent is spending the budget
Estimates are labelled
A synced pricing table, never a silent guess
06 · Robustness
Built to survive production
The failure paths are designed in, not discovered at 2am.
Retry with backoff is on by default for transient failures, and a fallback model takes over when the primary provider errors. An optional error output branch routes a failure somewhere useful instead of ending the run, and a workflow-level error handler node catches whatever the branches do not. Per-node and per-workflow timeouts stop a hung tool from holding a run open. Automatic context compression summarises the middle of a long tool loop before it overruns the context window, so long-running agents keep going instead of failing on turn forty.
Retry with backoff
On by default for transient failures
Fallback and error routing
Secondary model on error, error output branch, workflow error handler
Timeouts and compression
Per-node and per-workflow limits, plus automatic context compression
07 · Evals
Prove a change is better
Test suites for agents, scored, traceable and comparable across models.
Build suites of input cases with expected outputs and score them by exact match, contains, or LLM-as-judge with the judge reasoning shown so a pass is auditable rather than magic. Every case is a real engine run, so a failure opens as a full trace you can step through instead of a red cross with no story. Run a suite in one click locally or against your deployed workflow, and run the same suite across models to see what a cheaper model actually costs you in quality.
Three scorers
Exact match, contains, or LLM-as-judge with visible reasoning
Real runs, full traces
Every case is an engine run you can open and step through
Compare across models
Run the same suite on a different model and read the delta
08 · The assistant
An assistant that has actually read your canvas
Three modes, so AI help never turns into an edit you did not ask for.
Ask answers grounded questions about the graph and never edits it. Plan returns a proposal you review before applying, with animated playback of the change and a one-click revert. Agent is a live tool loop that builds for you, available with a Phorma Cloud subscription. Around those sit a Workflow Analyzer that reads your graph and recent run history and writes an improvement report, AI prompt drafting on any agent, and a migration converter: paste an n8n, Flowise or Dify workflow and get a reviewable plan for the Phorma equivalent.
Ask
Grounded answers about your graph, read only, never edits
Plan
A reviewable proposal with animated playback and one-click revert
Agent
A live tool loop that builds for you, with a Phorma Cloud subscription
09 · Agent Skills
Write a capability once, attach it anywhere
Agent Skills are portable markdown bundles that travel with the workflow.
A Skill is a markdown capability bundle you write once and attach to any agent, kept in a global library with SKILL.md import and export, duplication, and a used-by count so you can see what depends on it before you change it. Skills travel embedded in the workflow spec, which means a deployed workflow needs nothing from your local library in order to run. An AI drafter writes a first version from a short description, so a new skill starts as an edit rather than an empty file.
Portable by design
Embedded in the spec, so a deployment carries its own skills
SKILL.md in and out
Import, export, duplicate, and read a used-by count
An AI first draft
Describe the capability, then edit what comes back
10 · Sub-workflows
Compose workflows instead of letting one sprawl
Nest a saved workflow inside a run without losing the trace or the numbers.
An Execute Workflow node runs a saved workflow as a nested frame inside the same run, with scoped trace activity, the same debugger controls, and usage rolled up to the parent so cost still reconciles at the top. When a canvas has outgrown itself, select part of it and extract it to a sub-workflow in one action, recorded as a single undo step. Recursion is supported but bounded, with depth limits by plan, so a nested design cannot quietly become a runaway.
Nested, not detached
Scoped trace, shared debugger controls, usage rolled up to the parent
Extract in one action
Select part of a canvas and lift it out, as a single undo step
Halfway. Want to try it instead of reading about it?
Runs locally with Ollama. No account, no key, no cost.
11 · Version history
Version history with a restore you can trust
Every save is a version, and every restore is itself reversible.
Saves become versions automatically, with autosave coalescing and no-op suppression so the history stays readable instead of turning into noise. A semantic structural diff against current shows added and removed nodes, changed prompts, models, config and connections, and changed workflow settings, so you review meaning rather than raw JSON. Preview any version on a read-only canvas, then restore in one click, which keeps the pre-restore state as its own safety version. Deployed versions are pinned and never pruned. All of this is separate from in-session undo and redo.
Semantic structural diff
Nodes, prompts, models, config, connections and workflow settings
Read-only preview
Open any version on the canvas before you commit to it
Safe restore
The pre-restore state is kept as a safety version
12 · Portal
Ship a workflow to real users
Turn any workflow into a public chat page, a typed form, or a token-scoped API.
Portal serves from your own worker at your own domain, as a chat page, a typed form, or a JSON and SSE API. Multi-turn conversations work with no engine changes, because the transcript reaches your prompts as message and history variables. Embed it on any site with one script tag, theme it to match, and restrict it by origin. Scoped keys are shown once, stored only as hashes and revocable at any time, with rate limiting and per-visitor sessions built in.
The security posture is deliberate. Visitors receive a redacted event projection built as an allow-list rather than a filter, so nothing internal leaks by omission, and sub-workflow interiors are withheld wholesale.
An allow-list, not a filter
Prompts, node names, tool payloads, costs and raw errors can never reach a visitor
Scoped keys
Shown once, stored as hashes, revocable, origin restricted
Sessions and limits
Per-visitor sessions and rate limiting are built in
13 · Integrations
MCP is the integration surface
Every Model Context Protocol server is already a draggable tool node.
Rather than a hand-maintained connector library that grows at the speed of our roadmap, any MCP server becomes a Tool node on the canvas, so your integration surface grows with the whole MCP ecosystem. Local stdio servers and remote HTTP servers are both supported, with one-click presets for filesystem, git, fetch, memory, sequential thinking, Brave Search, Postgres, Slack, email and GitHub, plus bearer tokens and full interactive OAuth with PKCE. Secrets live in the OS keychain on desktop and as worker secrets in the cloud, never in the workflow file. Built-in HTTP request and web search tools cover the rest.
Local and remote
Local stdio servers and remote HTTP servers, both first class
One-click presets
filesystem, git, fetch, memory, Brave Search, Postgres, Slack, email, GitHub
Secrets stay out of the file
OS keychain on desktop, worker secrets in the cloud, OAuth with PKCE
14 · Deterministic data
Deterministic data, with no model in the path
For the work where a hallucinated number would be a business incident.
HTTP request, SQL query, transform, aggregate, assert, state get and set, and notify nodes execute directly in the graph walk with no language model involved, so the same input produces the same output every time. Pagination and batching handle real data volumes, writes are idempotent and backed by a durable run journal, and what was sent stays auditable afterwards. Agents sit beside the pipeline for the parts they are genuinely good at, such as summarising an exception or drafting the alert a human will read.
No model in the path
HTTP, SQL, transform, aggregate, assert, state and notify nodes
Idempotent writes
Backed by a durable run journal, with an auditable record of what was sent
Built for volume
Pagination and batching over real datasets
15 · Connections
Credentials that never travel with the workflow
A node holds a reference to a credential, never the credential itself.
Connections are a first-class credential entity stored separately from the graph. A node points at a connection instead of embedding a secret, which is what keeps a workflow spec safe to export, diff, version and push to a worker. It also means rotating a credential is one edit in one place, rather than a search across every node that happened to use it.
The spec stays safe
Export, diff, version and deploy without shipping a secret
Rotate in one place
Change the connection, not every node that references it
16 · Triggers and control flow
Start it however you like
Real triggers and real control flow, not just linear chains.
Run a workflow manually, on a cron schedule backed by real durable alarms, from a webhook, or from a Portal request. For-each loops iterate a collection with configurable concurrency. On the canvas, Router, Parallel, Aggregator, Approval Gate, Ask User and Wait For Event give you branching, fan-out, fan-in, human decisions and external waits as first-class nodes, so a workflow can express how the work actually happens instead of being flattened into a queue of steps.
Schedules that hold
Cron backed by real durable alarms, not a best effort timer
Webhooks and Portal requests
Started by another system, or by a real visitor
Control flow on the canvas
Router, Parallel, Aggregator, Approval Gate, Ask User, Wait For Event
17 · Models and providers
Any model, your keys
Choose a model per node, or inherit a workspace default.
Anthropic, OpenAI, Google Gemini, OpenRouter and Ollama are all supported, selected per node or inherited from a workspace default, so switching model is one setting rather than a refactor. Ollama means you can run a real multi-agent workflow with no account, no key and no cost, which makes evaluating the product free in the literal sense. Phorma Cloud subscribers can also run inference on plan credits with no key at all. On desktop, API keys live in the OS keychain and never enter the browser layer.
Five providers
Anthropic, OpenAI, Google Gemini, OpenRouter and Ollama
Zero-cost local runs
Ollama needs no account, no key and no spend
Keys in the keychain
Desktop keys never enter the browser layer
18 · Deploy
Local to cloud without a rewrite
The workflow you debugged is the workflow that ships.
One TypeScript engine runs your workflow in the app and inside a Cloudflare Durable Object, so deploying is not a second implementation. Deploy in one click to Phorma Cloud, managed and billed against subscription credits with nothing to configure, or to your own Cloudflare account, which is free and uses your keys and your domain with no Phorma fleet in the path. Live WebSocket monitoring means a deployed run animates on your canvas exactly like a local one. Workflows are portable JSON, so there is no exit tax.
Phorma Cloud
Managed, subscription credits, nothing to configure
Your own Cloudflare
Free, your keys, your domain, no Phorma fleet in the path
19 · Platform
Desktop-grade, and the same on every platform
A native app where it matters, and a browser build with the same canvas.
Phorma ships as a native desktop app on macOS, Windows and Linux with automatic updates, alongside a browser build running the same canvas. Storage is local-first, prompts are authored in markdown and rendered sanitized, and the interface uses Tabler iconography with light and dark themes and selectable accent palettes. A keyboard-driven command palette means the paths you use constantly do not need the mouse.
macOS, Windows and Linux
Native desktop with automatic updates, plus a browser build
Local-first storage
Your work lives on your machine by default
Themed and keyboard driven
Light and dark, accent palettes, and a command palette
20 · On the roadmap
On the roadmap, and honestly not built yet
Listed plainly so nothing else on this page needs to be read suspiciously.
These are planned rather than shipped, and nothing described above depends on them. If one of them is the reason you would buy, tell us and it moves up.
AWS deployment target
For regulated estates. Planned, not shipped.
Visitor sign-in on Portal
Planned, not shipped.
File uploads as Portal inputs
Planned, not shipped.
Full white-label
Planned, not shipped.
Packaged reusable connectors
Planned, not shipped. MCP covers integrations today.
Read enough. Go run one.
Download the Studio, point it at Ollama, and have a multi-agent workflow running in under five minutes. No account required.