AI agents that take real action. Control you can prove.
Amistio is one platform for automations that actually do work - built for individuals through governed enterprises. Describe an agent, attach approved tools and models, freeze an immutable version, and run it with approvals and evidence. The release contracts are implemented and verified today; the interactive workspace is still in development.
Every screenshot below is captured from the live builder: ready-made recipes that become your own agents once you confirm what they create, a visual canvas that validates before anything runs, and the whole thing working from your phone.
www.amistio.com/recipes
Recipes become your own agents: connect the integrations they need in one guided step, fill in your details, and activate. Browse the recipes
The same recipes on your phone - browse, connect, and activate on the go.
Building an agent
Compose blocks. Connect them. Let the agent do the work.
An agent starts as composable blocks - instructions, tools, knowledge, and approval rules. You connect them into a flow, and the released version acts on real systems with governance around every step.
Block builder with visual canvas - live on the embedded runtime
01
Pick the blocks
Start from typed building blocks: model instructions, tool capabilities, knowledge sources, and policy guardrails. Each block is versioned and reviewable on its own.
02
Connect the flow
Wire blocks together into an agent definition: which tools it may call, which data it may read, and which steps need a human approval before anything runs.
03
It gets to work
A frozen version is bound to an environment and starts taking real actions - every run checked against policy and recorded as tamper-evident evidence.
Who it's for
Beyond chatbots - for everyone with work to hand off
Chat that only answers questions was never the point. Amistio agents watch, decide, and act - and the same platform grows from one person's helpers to the flows that run a small business to enterprise fleets under proof.
For you
Live today
Personal agents beyond chat: watch for the things you care about, remind, book, file, and fetch - acting on your behalf, with your approval.
For small businesses
Live today
Compose the flows that run the company - lead intake to follow-up, order to invoice - connecting the tools you already use, no engineering team required.
For enterprises
Foundations implemented
The governance wedge ships first: identity, policy, approvals, and tamper-evident evidence for every action an agent takes.
One platform, not three products: the same versioned agents and controls everywhere, with governance you can switch on as you grow. The builder runs on this deployment's embedded runtime today - drafts freeze into immutable versions, runs pause at approval gates, connectors ship reviewed, and accounts and agent sharing are local to each self-hosted instance. Cross-instance sync and hosted execution are planned.
How it works
From idea to governed run
Four steps over the same release path the implemented contracts enforce - all four run in the live builder today.
Live end to end
01
Describe your automation
Start from the outcome you want. Define the trigger, typed inputs, and steps as a mutable AgentDraft you can edit and validate freely.
Contracts built
02
Connect governed capability
Attach models, MCP tools, and knowledge from a governed registry that records posture and integrity. Unknown tools are denied by default.
Contracts built
03
Freeze and approve
Release freezes the draft into an immutable AgentVersion. A Binding promotes one exact version per environment, and sensitive actions require human approval.
Contracts built
04
Run with evidence
Runs execute through a separated data plane with durable state, bounded retries on safe operations, and an append-only step record you can inspect - and export as a signed evidence document.
Live today
Every step above is the live product: drafts validate as you edit, versions freeze and publish, approvals park real runs, and any run exports as a signed, offline-verifiable evidence document.
Platform
One governed path from idea to operation
Authoring, governance, and runtime should share one semantic model. Amistio is being built so policy and evidence are part of the release path, not integrations added after deployment.
Foundation built
Compose
Define typed workflows with agents, models, MCP tools, connectors, knowledge, guardrails, approvals, routers, loops, transforms, triggers, and outputs.
Workflow definition contracts and deterministic validation are implemented.
Foundation built
Govern
Bind every action to tenant, identity assurance, policy, tool integrity, approval, and immutable release context.
Identity, policy, governed MCP registry, and versioning contracts are implemented.
In sequence
Operate
Run through a separated data plane with durable state, bounded retries, exact-call approvals, logs, eval gates, and evidence exports.
Portable state, queue, and secret-reference adapters exist; runtime and gateway are next.
Governance path
Governance is the workflow, not a review after it
The platform is designed to make every sensitive transition explicit: what tool entered the registry, whose identity authorized it, which policy decided, who approved, and what evidence remains.
01
Registry
Conformance, posture, integrity, lifecycle, and tenant enablement.
02
Identity
SSO and SCIM architecture with IdP-delegated MFA and step-up assurance.
03
Policy
Deny-by-default RBAC and ABAC behind a portable policy port.
04
Approval
Human-readable, exact-action approval for sensitive releases and calls.
05
Evidence
Append-only intent and outcome records tied to immutable versions.
MCP-native governance
Bring existing MCP under control without rebuilding it first
Amistio's wedge is adoption, not rip-and-replace. Register an existing MCP endpoint, record its authentication posture, pin its declared tool surface, and mediate future use through identity and policy.
Adopt existing estates
The accepted design explicitly includes n8n MCP Server Trigger and instance-level MCP endpoints.
Block on drift
Tool descriptions and schemas are integrity-bound; material drift requires review before reuse.
No live gateway claim
The governed registry contracts exist. Network adapters, real registrations, and gateway dispatch are still planned.
Architecture
Separate the planes. Keep the seams portable.
The control plane should never become the runtime, and a cloud convenience adapter should never become the product contract. Each plane has a narrow job and provider-bound code stays behind a port.
Control plane
Tenancy, registry, authoring, policy, approvals, evidence, and administration.
App planned
Execution and data plane
Governed tool/model dispatch, durable runs, bounded resume, and runtime isolation.
Service planned
Identity and policy plane
OIDC, SAML, SCIM, assurance, step-up, RBAC, and ABAC through portable boundaries.
Contracts built
Infrastructure plane
State, object storage, queue/scheduler, and secret references behind conformance-tested ports.
Partial adapter
Evidence plane
Tamper-evident intent, outcome, promotion, and audit records with explicit custody design.
Design gate
Readiness
What exists, what is next, and what stays later
The platform is being built in dependency order. This ledger is intentionally more useful than a launch claim: it separates verified foundation from planned product surfaces.
Implemented foundation
Contracts and portable persistence
Repository-local foundations are implemented and verified.
Enterprise identity and policy contracts
Governed MCP registry contracts and hostile vectors
Typed workflow definitions, versions, bindings, and canvas-view separation
PGlite state, queue/scheduler, and material-free secret-reference adapters
Next
Adapters, gateway, runtime, and control plane
These are the dependency-safe product units ahead.
S3-compatible object storage reference adapter
Identity protocol and approved policy-engine adapters
Shared product and control-plane app with the MCP gateway service
Durable runtime, exact approvals, eval gates, and evidence
Later
Self-serve entry, canvas, sovereignty, and task compilers
These remain gated expansions, not current product promises.
Bounded self-serve Personal Workspace entry over real runtime behavior
Desktop visual canvas and advanced collaboration
Customer-managed and self-hosted deployment options
Governed task-specific model distillation and organization template packs
No launch dates or general-availability claims are implied. Each stage advances only after its own contract, security, and verification gates pass.
Questions
Frequently asked
Straight answers about the enterprise direction, current readiness, and the boundaries we will not blur.
Not yet. The enterprise control-plane app, gateway, and runtime are in active development. The repository already contains verified identity, policy, MCP registry, workflow, and portable persistence foundations, but this page does not claim a generally available workspace.
Agent definitions depend on Amistio-owned contracts, not a hyperscaler's SDK. Models, identity, policy, state, object storage, queues, secrets, knowledge, runtime, and observability stay behind provider-neutral ports with shared conformance tests.
The design registers and attests servers, pins tool descriptions and schemas, records authentication posture, requires tenant enablement, authorizes each call against identity and policy, blocks material drift, and preserves revocation evidence. The contracts exist; live gateway dispatch and real server registrations do not yet ship.
The primary design delegates MFA to your identity provider through OIDC or SAML and consumes assurance claims such as acr and amr. Sensitive actions require step-up. SCIM lifecycle and provider adapters are planned behind IdentityPort; Amistio is not inventing a proprietary MFA stack.
No. Interoperability comes first. The accepted design explicitly supports governing existing n8n MCP Server Trigger and instance-level MCP endpoints, so teams can bring current automation under policy without rebuilding it before they get value.
No. Control-plane and data-plane separation preserves a future customer-managed or self-hosted path, but it is not a V1 availability claim. Packaging, upgrades, support, signing, and operational evidence need their own decision and implementation work.
Builders edit a mutable AgentDraft. Release freezes validated semantics into an immutable, content-addressed AgentVersion. An environment Binding points at one published version, so promotion and rollback move an explicit pointer instead of mutating what was approved.
That is a later, demand-gated expansion for eligible high-volume structured tasks such as extraction, classification, and routing. It comes only after the durable runtime, eval, licensing, tenant-isolation, regional-capacity, and promotion controls exist; it is not a general GPU platform or a current feature.
No. The accepted direction is one shared platform that serves individuals, small teams, and governed enterprises over the same contracts. Enterprise governance is the first wedge, and a bounded self-serve Personal Workspace is planned after the shared runtime exists. No self-serve entry is available yet, and this page makes no availability claim.
No. Amistio is one automation platform for individuals, small businesses, and enterprises. The builder is live today: design an agent as connected blocks, test the draft, freeze it into an immutable version, then publish and activate it for manual, webhook, or scheduled runs - all persisted on this deployment's embedded runtime, with approval gates and a reviewed, AI-native connector catalog. The enterprise governance foundations are implemented in the same open core, and hosted self-serve and team surfaces are planned on the same versioned, provider-neutral platform - not as a separate product.
Shape the right control plane
Build agent systems your security team can reason about
Whether you are one person automating your own work, a small business composing its operating flows, or a security team governing MCP and agent sprawl across an estate - tell us where today's tools break. This is a design conversation, not a general-availability promise.
