01 / 04
Skills compose reliably
Typed input and output contracts mean what you build once can be trusted by everything you build next. No brittle prompt chains. No silent failures downstream.
For builders
Build agents at scale. Without the complexity.
xFlo removes the engineering overhead of building, deploying, and managing production agents. Compose from a shared catalog of skills. Govern by default. Build for your own team or for your clients, ship faster, scale further. You focus on what the agents should do; the platform handles the rest.
The builder's reality
Building agents alone means building everything underneath them.
Every production agent needs the same supporting infrastructure. Auth and OAuth tokens for every tool. Memory to keep context across sessions. Cost attribution so you know what each run costs. Audit trails for compliance. Retry logic for flaky APIs. Trust gates so the agent does not act on a hallucination. The list keeps going.
Building this stack for one agent takes weeks. Doing it again for the next agent, and the next, does not scale. xFlo gives you the whole stack out of the box, so you build the agent, ship it, and move on to the next one.
Your agent
What you actually wanted to buildTrust gates and HITL
Memory and context
Cost attribution
Audit trail and replay
OAuth and permissions
Tool routing
Retries and error handling
Everything you build before the agent works
Infrastructure purpose-built for agent systems.
The shift is from building individual agents to building on governed infrastructure. Context is configured once and inherited everywhere. Governance is structural, not bolted on.
02 / 04
Agents orchestrate, they do not monolith
An agent is an orchestrator of composable skills. Reconfigure the agent without rewriting the skills beneath it. Reuse the skills across every agent you build.
03 / 04
Governance without bureaucracy
HITL gates and trust escalation are built into the foundation. Agents earn autonomy through demonstrated performance, not configuration.
04 / 04
Context compounds
The more xFlo knows about your organisation, the stronger every agent becomes. Memory is not a feature. It is the engine.
Composable skill architecture
Four capability levels. Same governance model.
Skills are the atomic unit of capability. Agents are the orchestrators. A skill built once is immediately available to every agent in the catalog.
- L1InstructionsNatural language defines the skill. Composable immediately. No configuration beyond the instruction itself.
- L2Instructions, toolsGmail, Slack, GitHub, Salesforce, Notion, Google Calendar, and 850+ more toolkits via managed OAuth.
- L3Instructions, tools, typed I/OThe skill has a contract. Errors caught at the boundary, not discovered in production.
- L4Instructions, tools, typed I/O, custom codeFull programmatic logic. All governance and composability primitives still apply.
Skill
Instructions
Tools
Typed I/O
Custom Code
Skill Builder and Agent Builder
Two builders. Both accessible two ways.
Skill Builder creates and configures individual skills. Go manual, or describe what you need and let the Builder Agent draft structure, suggest tools, and ask clarifying questions. Approve, edit, or reject each element.
Agent Builder assembles agents from the skill catalog. Describe the agent's purpose, review proposed skills and sequencing, deploy. Every proposal appears as a reviewable card.
Both paths produce the same output: production-grade, governed, cost-attributed skills and agents, immediately available in the catalog.
Skill BuilderManual
Name
draft_release_notes
Level
L1
L2
L3
L4
Tools
LinearGitHubSlack+ Add
TrustSupervised
Agent BuilderConversational
Build me a content marketer who can draft, review, and publish blog posts.
Proposing 4 skills + trust tier. Review each:
ResearchProposed
DraftProposed
ReviewApproved
PublishApproved
Governance built in
Move fast without breaking things.
HITL gates at any workflow step. Approve, reject, or edit before the agent continues. Full revision history on every decision.
Trust escalation: Supervised, Checkpoint, Autonomous. Agents earn autonomy through evidence, not configuration. You set the thresholds. The platform enforces them.
The six-layer cascade (Account, Workspace, Project, Thread, User, Skill) means governance is configured once and inherited everywhere beneath. You do not re-govern every agent.
Earned autonomy
01
Supervised
HITL on every output
02
Checkpoint
HITL at intervals
03
Autonomous
HITL on exception
Oversight decreases · quality-gated
Full visibility
Know exactly what every agent costs.
Per-skill cost attribution at account, workspace, project, and skill level. No black-box billing. Quality scoring per execution. The trust dashboard surfaces approval rates, edit distance, and execution patterns.
Immutable audit trail. Every action, every decision, every output recorded. You know what every agent costs, how it performs, and whether it can be trusted with more.
Billing · this monthUSD
Account$1,247.32
Workspace · Marketing$681.40
Project · Q4 Campaign$420.18
Skill · Draft$180.24
Skill · Review$95.10
Skill · Publish$144.84
Scale without rewriting
What you build once compounds.
Shared skill catalog
Skills built once are immediately available to every agent. Improve a skill, every agent that uses it improves with it.
Background and scheduled execution
Agents run within defined trust boundaries while your team focuses elsewhere. Spawn enrichment, run cron conversations, auto-pause on failure.
Workspace isolation
Client A never sees client B. What you build for one engagement becomes the foundation for the next, with data and cost boundaries intact.
Start building
Start building on governed infrastructure.
Start with a single skill. Build from there. The platform grows with what you build.