Automations
Create and distribute reliable AI automations
Add AI inference to a business process that removes unnecessary human-in-the-loop.
Automations
Add AI inference to a business process that removes unnecessary human-in-the-loop.
Someone was reading, reconciling, or joining data by hand. Now a governed blueprint does it — the same way, every time.
Explore use cases by team →
Pre-Call Prep
Sales
Pull the upcoming calendar event, mine every past Avoma meeting with the account, reconcile Salesforce contacts, and synthesize one prep document — before the call starts.
No more reconciling three tools by hand before a call.
Blueprint sequence
prep-call-analysis.fml
Find the meeting
Scope · list_events · get_events only
Find past calls
Window · last 180 days · same attendees
Analyze each call
Iterate · one pass per meeting
Reconcile contacts
Deterministic · queryContact · no model
Write the prep doc
Schema · prep_document
Reliable
Schema-validated output — the same shape, every run.
Inference only where judgment is needed. The rest executes deterministically.
Scoped sessions, so each step sees just the context it needs to get it right.
Distributed
Published once as both an API and an MCP endpoint.
Callable from your app, an agent, a schedule, or Slack, Claude, and VS Code.
Self-hosted on your infra and your keys, or run on Barndoor cloud.
Governed
RBAC, ABAC, and DLP enforced by the runtime, not asked for in a prompt.
Tool access declared in the blueprint, so the blast radius is visible in source.
Every run versioned, readable, and auditable.
FML is how you instruct an automation, and a Blueprint is what you end up with: A Blueprint runs exactly as written. It reaches for inference only where judgment is needed, and declares its inputs, tool access, and output shape upfront. Describe what you want. Convert a skill. Or write it yourself.
Start with intent
Explain the process in plain language. The assistant drafts the workflow file.
Import a prompt or skill. Barndoor Automations adds types, scope, and schema checks.
Every path produces
One executable blueprint
Typed inputs · scoped tools
checked output · version history
Start with source
Change the same source that runs—without local setup or an export step.
Use live diagnostics and validation, then review every change in Git.
Already using skills?
Describe the workflow in plain English. Barndoor Automations sub-agent explores your connected tools, writes the FML, fixes its own routing, and hands you a deterministic, schema-validated service — callable over API and MCP. No boilerplate. No glue code.
Sub-agent mode
Bring your own LLM key
Web IDE + VS Code
API + MCP callable
Consumers
Interfaces & triggers
Consumers
Interfaces
Triggers
MCP
API
Blueprint
AI automation, defined as code
Inference exactly where the process needs judgment—deterministic everywhere else.
Declare its inputs, decisions, tools, sessions, and output schema in one typed, executable blueprint.
Distribute
API · MCP server · Schedule
Govern
On Barndoor: policy on every call
Schema-validated output
Kept in run history
Runtime connections
Tools, data & models
MCP servers
Databases & APIs
LLMs
On Barndoor: the AI gateway
Your identity provider’s roles, and policy on every model and tool call
SSO / SAML
DLP from the gateway
Decision guide
A practical way to choose between simple rules, AI for one step, and a person's approval.
Five tightly integrated components turn an FML Blueprint into a governed, callable service — instruction, identity, routing, persistence, and execution.
Compiles your FML Blueprint into a schema-validated workflow.
Authenticates callers and enforces roles and tenant boundaries.
Authorize access
Directs each step to the right model, tool, or system.
Dispatch each step
Executes isolated sessions with guardrails, retries, and timeouts.
Run with control
Keeps versioned Blueprints, configuration, and execution history.
Preserve the record
One Blueprint. Governed from entry to execution.
Models + tools + systems
Inspect before you run
Review the executable source before it runs, watch each session as it executes, and keep the record it leaves behind. Logs, run history, and developer debugging are part of the platform—not a separate observability stack you assemble yourself.
Before the run
The browser editor shows executable FML beside its dependencies—tool access, sessions, and output rules declared in the file itself. No hidden diagram-to-code step.
During the run
Execution is sandboxed and observable at every step, with per-step guardrails, retries, and timeouts. A failure points at the session that caused it instead of a black box.
After the run
Every run is versioned and kept as execution history—30 days on Free, up to unlimited on Enterprise, where SSO, SAML, and exportable audit logs come with it.
For developers
The FML language server gives real-time diagnostics as you write, and frags debug runs the same Blueprint locally. Connections resolve by name, so nothing changes between local and hosted.
How we compare
Zapier, Make, n8n and Workato all support AI workflows, with different ways to shape outputs and control access. A Blueprint puts the workflow in one file, validates a declared output schema, and, on Barndoor, applies identity and policy to each step.
See the full comparisonvs. Zapier
Zapier supports typed output fields in AI steps. A Blueprint keeps the output schema, tool scope and workflow together in one file you can review in Git.
Comparevs. Make
Make supports structured agent responses and scenario outputs. A Blueprint puts inputs, tools and the output schema in one file you can review in a pull request.
Comparevs. n8n
n8n offers AI Agent, parser and Guardrails nodes. A Blueprint declares context, tools and an optional output schema in the same file as the workflow.
Comparevs. Workato
Workato has enterprise controls and structured AI output. A Blueprint gives you one reviewable FML file and an open-source runtime you can operate yourself.
CompareHow Blueprints work, where they fit, and what it takes to get started.
Have a different question?
Talk to our teamA skill's guardrails are suggestions an LLM can talk itself out of, and it runs locally on one person's machine — which makes it hard to trust and harder to distribute. A Blueprint constrains the model step by step: what's deterministic stays deterministic, inference is used only where judgment is needed, and access control is enforced by the runtime rather than by the prompt.
Publish it and it becomes a governed service — an API or MCP endpoint anyone with the right access can call, reliably and repeatably.
n8n, Zapier, and the rest handle deterministic steps well — right up until a step needs judgment, where they stop. Skills go the other way: they'll reason about anything, but that inference isn't governed, so “right most of the time” is as good as it gets.
A Blueprint does both in sequence: deterministic steps run as written, and the inference between them is fenced in by scoped context and a schema it has to validate against.
It's also stored as source rather than as a canvas — reviewable in a pull request, diffable between versions, and roll-back-able like any other code — and published as an API and MCP endpoint anyone with the right access can call, instead of living on the laptop that built it.
Three things, enforced by the runtime rather than asked for in a prompt:
No. You can describe what you want in chat and the assistant writes the FML for you, or drop in an existing skill and Diaphora converts it into a typed blueprint. FML is there when you want to read, review, or hand-tune what actually runs — which, eventually, you will.
The model still writes the words; the Blueprint controls everything around it. Each session gets a scoped context instead of one sprawling prompt, and every session declares a schema its output must validate against. So the shape of what comes back is fixed and machine-consumable, even though the prose inside it varies.
Anything exposed over MCP, plus REST APIs and your own functions. Blueprints declare their requirements up front — including an optional allowlist of the specific methods a session may call — so a blueprint's blast radius is visible in the source rather than discovered at runtime.
You call them like any other service: over an API, as an MCP server for another agent, on a schedule, or from Slack, Claude, ChatGPT, and VS Code. The same Blueprint backs all of them — you author it once rather than rebuilding it per surface.
The Free plan is free forever — one user, 1,500 credits a month, no credit card and no expiry. Starter is $50/mo and Team is $200/mo (both cheaper annually), and paid tiers add credits automatically if you run past your allowance rather than throttling your runs.
Join engineers, operators, and builders who are done shipping skills and ready to ship services. Deterministic, repeatable, production-grade — by design.
Not ready to sign up?
