Diaphora — AI Workflow Automation That Runs Like Real Code

Blueprints for production AI

Create and distribute reliable AI automations

Turn a plain-language goal into a governed blueprint—then deploy it as a reliable automation anywhere.

Consumers

Interfaces

Triggers

Diaphora pipeline

DBs & APIs

LLMs

Google Gemini

\ Slack](/content/integrations/slack/index.html)
\ Claude](/content/integrations/claude/index.html)
\ ChatGPT](/content/integrations/chatgpt/index.html)
\ VS Code](/content/integrations/vscode/index.html)
\ Claude Code](/content/integrations/claude-code/index.html)
Cursor\ Cursor

See all integrations

The Problem

Your best skills are still just prompts.

You shouldn't need a hardening guide just to trust your own skill in production. Diaphora makes that work unnecessary. Do your skills…

Before After
Give a different answer every time? Schema-validated. Same shape, every run.
Only work one way? Callable as an API, MCP server, or scheduled job — same blueprint.
Only run on your laptop? Self-hostable. Your infra, your keys, or Diaphora cloud.
Are not distributable? Runs centrally — callable by your whole team, not just you.
Need a human to sign off? Governed automatically — RBAC, ABAC, and DLP enforced on every run.
Access more than they should? Scoped sessions. Each call sees only the context and tools it needs.

Sound familiar? Graduate your skills into services.

Convert a skill file

Or book a demo →

See how this compares across harnesses, iPaaS, and orchestration frameworks too →

Frags Runtime

The OSS runtime for AI-powered backend services.

Frags is an advanced LLM agent built to execute complex workflows of data retrieval, transformation, extraction, and aggregation. It optimizes for precision and focus — a system for engineers and specialists, not a code-free quick fix. It ships as a CLI tool and a Go library.

Multi-LLM

Open-source runtime
View the open-source runtime on GitHub

frags · cli

$ frags run sales-blueprint.fml --llm claude

▸ compiling FML blueprint ............ ok
▸ session sales_plan
queryOpportunity → 42 rows
schema validated → 2 fields
▸ session notify_team
chat_postMessage → #sales
schema validated → 2 fields
✓ blueprint complete · structured output ready

Multi-LLM

Bring the model that best fits the task — and your own API key. Frags routes to any supported LLM: Claude, GPT, Gemini, or a local Ollama model.

$ frags run plan.fml --llm claude

Structured output

Frags exists to produce predictable, machine-consumable data — not chat. Every output is typed and validated.

plan.fml

schema {
    title: string
    score: int # validated on every run
}

Orchestration system

Describe complex retrieval, transformation, extraction, and aggregation to build rich data structures — not one-shot answers.

plan.fml
session("gather") { ... }
session("rank", after="gather") {
    \- Rank what "gather" produced.
}

Advanced tooling

A standardized system for integrating internal tools you provide and external MCP servers.

plan.fml
require mcp Slack
session("summary") {
    use mcp Slack
}

Anti-context-bloating

The multi-session model scopes exactly what enters each LLM context, improving focus and cutting hallucination risk.

plan.fml
session("rank", after="gather") {
    # only this lands in context — nothing else
    context "{{ json .context.gather }}"
}

Output segmentation

Split output across sessions to beat token limits and raise answer quality on large results.

plan.fml
session("expand", after="gather",
    iterate="context.gather.points") {
    schema string[] # one result per item
}

Pre / post-processing

Custom scripts, tools, and transformers do the deterministic work — less LLM load, lower cost, better performance.

plan.fml
transformer("clean") {
    onFunctionOutput = "history"
    jmesPath = "messages"
}

Modularity

Built to be extended — add capabilities and wire Frags into your own tools and processes.

plan.fml
components {
    schema("SourceRef") {
        url: string
    }
}

How you build

There's no drag-and-drop canvas. That's the point.

Node-wiring builders feel friendly until the workflow gets real. Diaphora builds blueprints the way engineers actually work.

Open any blueprint in the browser and you see the actual source — parameters, MCP requirements, sessions, and prompts — not a diagram that approximates it.

Or build it your way

VS Code extension

Build, edit, and validate blueprints without leaving your editor. Version them in git like the code they are.

Platform Architecture

Instruction Engine Core

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

  1. FML, the blueprint language
    Workflows are written in FML — the Frags Modeling Language — and compiled for a deterministic runtime.
  2. Secure by design
    The authenticated entry point for everything calling Diaphora — enterprise SSO, federation, role-based access, and multi-tenant isolation.
  3. Intelligent dispatch
    Routes every workflow step to the right LLM or system while keeping execution deterministic.
  4. Persistent state
    Versioned blueprints and connection history — full auditability for every run.
  5. Execution environment
    Sandboxed 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.

Sub-agent mode

Bring your own LLM key

Web IDE + VS Code

API + MCP callable

Run the interactive demo

sales-plan.fml

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

Create blueprint

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.

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.

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.

Plot twist

Does building reliable AI automations make you want to say FML?

Good news — that’s just the name of the language. FML is a programming language for instructing LLMs, running on the Frags runtime.

Use Cases

Where the human-in-the-loop wasn’t necessary.

Someone was reading, reconciling, or joining data by hand. Now a governed blueprint does it — the same way, every time.

FAQ

The questions we actually get