Aflow runs work that unfolds over days and weeks. A skill is a directed graph of typed steps, and every task carries its own model, tool grant and output contract. Memory is stored in the space and supplied to each new run. Sessions are shared: several people work alongside the agent, resolve the decisions it pauses for, and continue the work in any later session.
Access is limited to a few invited testers — bring-your-own-model-keys.
Durable execution
Starting a skill creates a run: a process that survives restarts, pauses for input without timing out, and resumes from the step that stopped. Every step records its operation, inputs, outputs, duration, token cost and status. A run starts from a conversation, a schedule, or an inbound webhook.
Push the house-prices model past 0.85. Start from last week's feature set and keep going until it clears.
Representative run · a fixed example, drawn with the product's own surfaces.
Ask in the space. The Helmsman selects the skill, fills its inputs and starts the run.
human.chat.askCron, one-shot, or on-completion of another run. Leased and de-duplicated, so a fire happens once.
agent.schedule.* · 0 7 * * 1A public HMAC-verified endpoint per space. Filter and map the payload, then start a session from it.
POST /v1/webhooks/ingest/…Skills & contracts
Three fixed roles run every skill: one holds the conversation and delegates, one executes a single task, one reviews finished runs. The skill itself is an authored graph, and each task declares the model, tool grant, attempt budget and output shape it runs under.
Holds the conversation, reads the space, decides what to start, and delegates a task.
Never executes a task itself.
Receives one fully specified task, works it, returns a value that satisfies the contract.
Never delegates, and never spawns another agent.
Reads finished runs against recorded evidence and proposes changes to the skill.
Never applies a change; an operator ratifies it.
{ "type": "object", "required": ["lbValue", "params", "foldScores"], "additionalProperties": false, "properties": { "lbValue": { "type": "number", "minimum": 0, "maximum": 1, "description": "The cross-validated score this run achieved. Reported from the sandbox run, never estimated." }, "foldScores": { "type": "array", "minItems": 5, "maxItems": 5, "items": { "type": "number" } }, "params": { "type": "object", "required": ["learningRate", "maxDepth", "nEstimators"] } } }
Multi-agent systems commonly let the model decide the org chart at runtime, spawning sub-agents and negotiating who does what. A run assembled that way is hard to reproduce, budget or debug. Here the three roles and their wiring are identical in every space and every skill, and the graph is authored before the run starts — two operations run in parallel because the graph says they can. Only the per-task configuration changes.
What the contract enforces is shape: required fields present, types correct,url matching ^https?://. A turn that misses any of it is rejected and re-run against its attempt budget, and a model that keeps missing parks the run as a contract violation with the failure named.
The Coach reads finished runs against recorded evidence and proposes a change to the graph, which an operator ratifies. Validity is recomputed on every read, so a proposal that would break the skill is reported as such before it is applied.
Human-in-the-loop
Every catalog endpoint carries a write-risk tier. Medium and high-risk calls pause after the request body is resolved, show the exact bytes to be sent, and resume only on an authenticated approval.
{
"dataset": "house-prices-features",
"version": 4,
"reason": "superseded by target-encoded v5"
}A task needs a Kaggle binding this space doesn't have yet. The run is parked, not failed — it picks up where it stopped once the connection exists.
Raise the fold count from 3 to 5 before scoring. Evidence: fold variance exceeded the score gap on 4 of the last 6 runs.
Multiplayer
Sessions carry a durable participant roster and live presence. Any member can take the decisions a run is waiting on, and shared applet state is written through the same gateway the agent uses.
People are invited into the run itself, so someone who joins on Thursday reads what happened on Monday. Presence is delivered on the same event stream as the run: who is here, who is typing, who is looking at which step.
A click in the applet and an agent calling ui.applet.act go through the same gateway: authorize the seat, validate the input, compare-and-swap on the version, bound the patch, snapshot. Every action carries an id, so a repeat replays and a stale one comes back as a conflict.
Permissions come from the space, so there is one model to keep in sync and no shareable back door into a run. An approval waiting in the Action Center can be assigned to a named owner.
Memory
The conversation it is in, the ledger of past skill executions, and the space store every skill and agent shares. Each agent turn gets a curated attention window drawn from all three, itemised so you can see what went into it.
Target encoding beat one-hot on the high-cardinality columns by 0.011 lbValue, and the gap held across all five folds. Report the fold spread alongside the mean; a single-fold claim has misled two runs already.
Recorded by run #8. Superseded the note in [[cv-fold-variance]], which measured on three folds.
The agent reads back its own thread, including earlier tool results. Large results are held by reference, so a 40MB artifact stays addressable without ever occupying the window.
It can look up a specific skill or a specific past run — its steps, inputs, outputs, scores and cost. That is how a run started in one session is picked up in another, and how the Coach reviews what happened.
Documents, notes and recorded learnings sit in one space-scoped store that every skill and agent in that space reads and writes. A task declares the scope it needs, and reads are budgeted, so what reaches the window is curated for that turn.
A note names a related idea inline as [[a-wikilink]] and the store resolves those into a graph: what this document references, what references it. A link to a note nobody has written yet is kept as a ghost, which is how the agent finds the gaps worth filling.
A write queues the document for indexing and reports the status back. Content is split by what it is — prose by paragraph, JSON by node, a dataset by row — so a large file stays searchable in full. Rows land in the text index and prose in the vector index, which is why grep and semantic search reach different things. Images, audio and video are stored and addressable, and skip embedding.
Goal-driven campaigns
A skill declares a goal and the outcomes that satisfy it. A campaign binds it to a metric, a direction and a target, then runs it repeatedly — each run scored, plotted, and recording what it learned for the next run to read. The loop stops when the outcomes are met, or on its run, cost or time budget.
Integrations
A task can call any of 165 built-in operations. Beyond those, any HTTP API and any MCP server becomes callable the same way, installed into a single space and granted to individual tasks.
An HTTP endpoint and an MCP tool arrive as the same kind of capability, discovered, bound and called through the same path. Aflow is itself an MCP server, so any MCP client can drive it in the other direction.
Connectors, skills and applets install into a space and stay scoped to it. Two spaces can hold two different Notion accounts, each blind to the other's credentials.
An agent starts from a small default set, and each task declares the operations and endpoints it may call. An operator sets what the default is for the space.
Models & BYOK
Frontier models and open weights are addressed through one catalog, with the model set per task. Aflow calls each provider with the credentials you supply.
Coding agent
Author the coding pipeline, define branches per case, and automate it with human approval gates. Each run records learnings that the next one reads.
Access is limited to a few invited testers, on your own model keys. If you're working on similar problems, or want the architecture in more detail than a landing page can carry, get in touch.