Deterministic orchestration for real systems
Argyll is a goal-driven orchestration platform built for systems with callbacks, retries, delays, long-running work, and probabilistic services. It keeps execution predictable while giving you a cleaner model than hand-maintained process logic.
Instead of hard-coding and updating every path, you define the outcomes that must be satisfied, and Argyll resolves and executes the work required to reach them.
Argyll is a goal-driven orchestrator. Services describe their capabilities as Steps with named inputs and outputs. A Flow names the outcomes it wants, and Argyll builds the smallest execution plan that can produce them. Independent work runs in parallel, shared dependencies run once, and every state change is recorded for inspection and recovery.
How it works
A Step wraps an HTTP endpoint, an inline Lua script, or a reusable child Flow and declares the Attributes it consumes and produces.
Start a Flow with Goal Steps and initial values. The Goals are the downstream outcomes this execution must produce.
Matching Attribute names connect Steps. Argyll works backward from the Goals to find their producers and runs each dependency when its inputs are ready.
Committed events determine what runs next, giving retries and recovery the same durable state that operators inspect.
Why Argyll
Argyll gives independently deployed services one execution model for dependencies, retries, asynchronous completion, compensation, and recovery. Execution is durable: every Flow is rebuilt from its committed events after a restart and continues from where it stopped, without repeating completed work. Once a capability is registered as a Step, any new Flow whose Goals depend on its outputs can include it in the Plan.
For example, an order Flow can name shipment and notification as its Goals. Their Attribute requirements pull payment, inventory, and customer lookup into the Plan, share common results between both Goals, and leave unrelated capabilities out of that execution.
Orchestrating AI
Model calls are slow, costly, and can answer differently every time. In Argyll, a prompt, an agent, or a tool call is an ordinary Step that declares the Attributes it consumes and produces, and the Plan decides when it runs. The work around the model stays deterministic even when the model does not.
Argyll gives AI workloads durable execution. Every model output is committed as an event before downstream Steps consume it, so a crash, a restart, or a failed downstream Step resumes from the recorded answer instead of starting over. Recovery never pays for the same generation twice or gets a different result. Independent model calls run in parallel, long generations complete through async callbacks, and timeouts and retries come from Step configuration instead of hand-written glue.
Agents can drive Argyll as well. The Argyll MCP server lets an agent register Steps, preview Plans, and start Flows, while the engine decides what actually runs. The agent chooses the outcome, and Argyll keeps the execution bounded, recorded, and inspectable.
git clone https://github.com/kode4food/argyll.git
cd argyll
docker compose upThen follow the Quick Start to register Steps, start a Flow, and inspect its result.