Book a demoStart free

Blueprints for production AI

Create and distributereliable AI automations

Add AI inference to a business process that removes unnecessary human-in-the-loop.

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

RBAC · ABAC · DLP on every run

Schema-validated output

Versioned & auditable

Runtime connections

Tools, data & models

MCP servers

DBs & APIs

LLMs

Google Gemini

IAM & Gateway

Enterprise SSO, SAML, and federation at the door

SSO / SAML

Native DLP — PII protection

Runs where you already work

Slack

Claude

ChatGPT

VS Code

Claude Code

Cursor

Cursor

See all integrations

What you'll get

Your best AI automations need to be Blueprints.

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 Diaphora 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.

Book a demo →See how Blueprints change the way you approach automations →
Start building

Start building reliable AI automations you control.

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

  • Describe the outcome

    Explain the process in plain language. The assistant drafts the workflow file.

  • Bring a trusted skill

    Import a prompt or skill. Diaphora adds types, scope, and schema checks.

Every path produces

prep-call.fml

One executable blueprint

Typed inputs · scoped tools
checked output · version history

Start with source

  • Edit in the browser

    Change the same source that runs—without local setup or an export step.

  • Work in your IDE

    Use live diagnostics and validation, then review every change in Git.

Different starting points, one artifact your team can read, review, and version.

Already using skills?

Use Cases

Work that never needed a 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 →

All

Sales

Executive

Customer Success

Product

Platform

IT Ops

Marketing

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.

View Full Blueprint

No more reconciling three tools by hand before a call.

Tools

Google Calendar

Avoma

Salesforce

Sessions

1

calendar-details

2

find_meetings

3

analyze_meetings

4

generate_prep_report

Schema Output

✓

calendar_details

✓

meeting_analyses

✓

crm_report

✓

prep_document

Platform Architecture

Instruction Engine Core

Five tightly integrated components turn an FML blueprint into a governed, callable service — instruction, identity, routing, persistence, and execution.

01

FML, the blueprint language

Instruction Engine

Workflows are written in FML — the Frags Modeling Language — and compiled for a deterministic, open-source runtime. Define once; run reliably every time with full schema validation.

02

Secure by design

IAM & Gateway

The authenticated entry point for everything calling Diaphora — enterprise SSO, federation, role-based access, and multi-tenant isolation, with a full audit trail.

03

Intelligent dispatch

Router

Routes every workflow step to the right LLM, tool, or system while keeping execution deterministic — model-agnostic, with fallback chains and cost-aware scheduling.

04

Persistent state

Storage

Versioned blueprints, parametrized configs, connections, and immutable execution history — full auditability for every run.

05

Execution environment

Runner

Sandboxed, observable execution of each session with per-step guardrails, retries, timeouts, and integration hooks.

AI-native backend services in under 10 minutes.

Describe the workflow in plain English. Diaphora's 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

sales-plan.fml

Copy

VALID

1

system("You are an expert sales assistant.")

2

 

3

require mcp Salesforce

4

require mcp Slack

5

 

6

session("sales_plan") {

7

    use mcp Salesforce

8

 

9

    # Fetch open opportunities for the current quarter

10

    call("queryOpportunity") -> opportunities {

11

        fields = "Id, Name, Amount, CloseDate, StageName"

12

        where  = "CloseDate = THIS_QUARTER AND IsClosed = false"

13

        limit  = 50

14

    }

15

 

16

    + Review my open opportunities for this quarter:

17

      {{ .vars.opportunities | json }}

18

 

19

      Analyze these opportunities and create a weekly sales blueprint for me.

20

      Identify priority deals, group them logically, and outline the key

21

      actions I should take this week to move them forward.

22

 

23

    - Produce the detailed weekly sales blueprint, plus a concise summary

24

      that I can share with the broader team.

25

 

26

    schema {

27

        salesPlan: string # The detailed weekly sales blueprint with steps

28

        summary:   string # A concise summary ready for Slack

29

    }

30

}

31

 

32

session("notify_team", after="sales_plan") {

33

    use mcp Slack

34

 

35

    # Automatically send the summary to the sales channel

36

    call("chat_postMessage") {

37

        channel = "123456789"

38

        text    = $(context.sales_plan.summary)

39

    }

40

 

41

    - Confirm the summary was posted to the sales channel.

42

 

43

    schema {

44

        posted:  bool    # Whether the summary was delivered to Slack

45

        channel: string  # The Slack channel the summary was sent to

46

    }

47

}

Create blueprint

~4 min elapsed

Build me an automation that pulls my opportunities for the quarter and creates my weekly sales blueprint. Additionally, Slack the sales summary to my sales channel — 123456789

Tool: list_available_tools

Tool: list_mcp_commands

Tool: list_mcp_commands

This blueprint fetches your open opportunities for the current quarter from Salesforce, drafts a weekly sales blueprint with a concise summary, then uses a deterministic tool call to send that summary to your Slack channel (123456789). Just make sure the Salesforce and Slack MCP tools are connected.

Tool: update_plan

Tool: update_plan

Compiled and schema-validated — the blueprint is clean and ready to run. It will query your Salesforce opportunities for the quarter, assemble the weekly sales blueprint and summary, and post that summary directly to your Slack channel.

Type a message…

Inspect before you run

Debug, observe, audit.

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.

FAQ

The questions we actually get

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.

Limited Beta Access

Stop re-prompting.
Start shipping.

Join engineers, operators, and builders who are done shipping skills and ready to ship services. Deterministic, repeatable, production-grade — by design.

Start freeBook a demo

No credit card required

Not ready to sign up?