sam 0b8014516a feat(workflow): agent-call children, call steps, and the waited-on callee sweep
Plan item 4 of docs/prds/execution-tree-state-machine.md (archie-core-1216),
plus the callee half of CancelExecution that plan item 5 deferred until the
tree could decide it.

Every agent call a stage makes records itself: AgentStage's bridge, the
baseline-fix auto-fix run, the adversarial reviewer and a workflow.call each
start a child StepExecution of kind agent or call under the stage's own step
-- TaskContext.StepID, which the engine sets before the stage body starts and
clears when it returns -- and finish it with the call's own outcome and the
tokens it accounted. A child's recording write failure parks the execution
the same way a stage's does: an agent call that ran unrecorded is the
invisibility the step table exists to end. A stage invoked outside the
engine's recorded run -- the stage unit tests -- records no child and runs
unchanged.

The call step is what makes the callee half of the PRD's Cancellation section
decidable, and this lands it: a call step closes when its callee ends, so an
open call step is a callee the caller waits on (wait:true) and a closed one
is a wait:false callee that runs on. CancelExecution reads the open call
steps before its sweep closes them and cancels each named callee through its
own CancelExecution in the caller's write's aftermath -- the callee's own
steps, its own events, its own move to the same destination, and the callee's
own wait:true callees beyond it, the depth the enqueue enforces bounding the
recursion. A callee that cannot be cancelled is reported and the caller's own
record stands.

StartStep refuses a call step whose callee is not this run's own (the
callee's call_parent_task_id must name the recording execution): a
compromised container could otherwise record a step naming a foreign
execution and cancel it. StartStepRequest gains called_execution_id (field 6;
non-breaking, the column and its named consumer already exist) and
StepStart carries it.

PRD decisions recorded here:
- The reviewer records as one agent child named "review": the Reviewer
  contract runs one subagent per review, the PRD model's review:1/review:2
  are illustrative of depth-1 children. A completed report closes it
  succeeded, a not-run review failed with the skip reason; the contract
  carries no usage, so tokens are 0.
- A failed-callee call step closes as failed with the callee's detail when
  the wait ends otherwise; the single open case is the caller itself being
  cancelled, whose CancelExecution already swept this step -- a late write
  must not pretend the wait is still the caller's business.
- A call step's callee is cancelled to the same destination the caller's
  action named (parked stays parked, closed_wont_do ends the whole chain),
  and a callee that cannot be cancelled is reported while the caller's own
  record stands either way.
- The agent child's detail is the result summary on success and the error's
  text on failure, with the call's own TokensUsed -- the PRD's only usage
  field, untracked per call for the reviewer contract.
2026-09-27 07:14:15 +10:00
2026-09-26 10:32:39 +10:00

Quality

Archie

Event-driven Agentic Automation

Archie connects events from your systems to agents that can investigate, reason, and act. Define what an event means, map its data into a workflow, and give that workflow an agent equipped for the job: its own execution environment, tools, and identity.

The aim is to automate work across system administration, incident response, network operations, service management, and software delivery. You define the process and the access it requires; agents work through its stages, using the context of each event to decide how to accomplish the task.

Archie is under active development. The model below describes the project's approved direction, with implementation progressing across event automation and organisation access control. The event automation design and organisations and access design describe those capabilities and their delivery stages.

From an event to an outcome

Event source → Event type → Mapping → Binding → Workflow → Agent
Concept Purpose
Source Receive events from a system such as a firewall, monitoring stack, service desk, or forge. Configure its endpoint and signing requirements.
Event type Identify which kind of event arrived from its headers and payload. Infer a schema from captured events or a pasted example.
Mapping Extract named, typed parameters from the event. Reuse a mapping across bindings and see how often it matches.
Binding Select a workflow, filter the events that should trigger it, and supply its inputs from mapped values or constants.
Workflow Define the stages of work, their inputs and outputs, and the agent profile to use. Call other workflows when work needs another specialist or process.
Agent Execute the work in a container with the tools for its purpose, acting under its own identity and granted permissions.

A single source can produce several event types. An event type can feed several bindings, and each binding can apply its own conditions. This lets the same incoming data drive different responses without building a custom integration for every workflow.

For example, a firewall sends a blocked-connection event. Archie identifies the event type and maps the source address and severity into an investigation workflow. A network investigator gathers evidence, assesses the activity, and returns its findings. The workflow could then call a separate containment workflow, subject to the permissions and approvals configured for that action.

The same model supports other processes:

  • Infrastructure operations: A monitoring alert starts a diagnostic workflow to inspect a service, collect evidence, and propose or perform an authorised recovery action.
  • Service management: An incoming request supplies the parameters for a triage, investigation, or fulfilment workflow.
  • Software delivery: A forge event starts a review or implementation workflow with the repository's toolchain, validation steps, and pull request as its output.

These are examples of workflows you can build. Their behaviour comes from the workflow, tools, and access you configure.

Agents equipped for their work

An agent profile selects the container image and available tools. You can supply images with the software needed for a particular environment: network utilities for an investigator, operational tooling for a systems agent, or a language runtime and test framework for repository work.

Workflows declare structured inputs and can return structured outputs. They can run with a scratch workspace, require a repository, or accept one optionally. An investigation can finish with a report; a maintenance workflow can finish with an operational result; a coding workflow can finish with a pull request.

Workflows can also call other workflows and pass data between them. Each called workflow has its own run and agent profile. A caller can wait for the result or continue while the called workflow runs independently.

See the firewall investigation example for a workflow that uses typed inputs, a network investigator profile, and no repository.

Organisations, identities, and controlled execution

The approved access model organises automation into organisations and workspaces. An organisation owns its members, agent identities, secrets, profiles, and workflows. Workspaces group sources, mappings, bindings, and runs by team responsibility or environment, such as network operations in production. Each organisation can enable the default workflows it needs and add its own.

Agents act as their own identities. A workflow names the identity it runs as; secrets and permissions are granted to that identity. Starting an agent is an audited action, with a record of the workflow and the event or member that initiated it.

The design combines roles for routine administration with attribute-based policies for resources and execution context. Policies apply from the instance through the organisation, workspace, identity, workflow, and individual object. Lower levels can narrow access, and a denial takes precedence. Organisation and workspace policy also determines which actions require approval from another member.

Authorised runs receive credentials scoped to their identity, workspace, and work. Event data supplies the task's inputs; it cannot grant additional access. The organisations and access design defines this model; it remains an active implementation area.

Building and operating automations

The dashboard brings together event inspection, mappings, bindings, workflows, and task activity. The intended authoring path starts with a real payload or an example: identify its structure, map the fields you need, select a workflow, and approve the binding.

Sources default to signed delivery. The event automation design also allows an explicitly approved unsigned source for systems that cannot sign payloads, with that status visible to operators. Binding changes require re-approval before they can dispatch work.

Playbooks and extension points provide additional orchestration through workflows, modules, channels, and forges. The playbook engine design describes how registered capabilities become actions that event rules can call.

Develop locally

The repository requires Go 1.27, Task, Node.js and npm, and Docker with a running daemon. The development stack starts PostgreSQL 18 through Docker Compose. Install the Go formatting and lint tools listed in CLAUDE.md before running the full quality gate.

task dev

Open http://localhost:5173 for the dashboard with Vite hot reload. task dev starts the daemon, Gateway, State Store, UI service, and frontend development server; it uses deployments/dev.toml as a local configuration overlay. Set credentials and other required settings in your local Archie configuration as needed.

Useful checks:

task build       # build the service and agent binaries in bin/
task test        # run the short Go test suite
task check       # run the repository quality gate

Deploy

Start with the deployment examples. They cover a single GitHub forge, multiple GitHub and Gitea identities, local Ollama, and an external NATS stack. Copy a suitable template to ${XDG_CONFIG_HOME:-~/.config}/archie/config.toml, then set its repository, model, credential, and service settings for your environment. The examples describe the required PostgreSQL connection and how to start each process. A systemd user service guide is available, but systemd is optional.

Documentation

Contributions should follow AGENTS.md, including its testing, generated-file, and commit rules.

S
Description
Archie connects events from your systems to agents that can investigate, reason, and act. Define what an event means, map its data into a workflow, and give that workflow an agent equipped for the job: its own execution environment, tools, and identity.
https://archie.catlow.cloud
Readme Apache-2.0
133 MiB
0 Stars 1 Watchers 0 Forks
2026-11-10 10:01:23 +00:00
Languages
Go 76.7%
Vue 13.1%
TypeScript 7.8%
JavaScript 1.2%
Shell 0.6%
Other 0.4%