Multi-agent orchestration with
memory that compounds.
Construct is a Rust-native AI agent runtime where every plan, tool call, trust score, and outcome lives in the Kumiho graph. Declarative YAML workflows, an embedded web dashboard, and bring-your-own-LLM — without losing the trail.
Agents without memory are calculators, not workers.
Construct treats the graph as the substrate every agent wakes up in. Plans, sessions, trust scores, and tool calls all become first-class graph entries — queryable across runs, auditable across teams, and reusable across templates.
Persistent memory
Every session, plan, skill, and outcome is a versioned Kumiho item. Cross-session recall is automatic.
Declarative workflows
17 step types — agent, supervisor, group_chat, map_reduce, human_approval — composed in plain YAML.
Trust-scored agents
Every execution scored. Higher-trust agents are preferred by the supervisor pattern automatically.
Reactive graph
Tagging a Kumiho revision fires downstream workflows. No cron, no glue scripts, no webhooks.
Who Construct is built for
If you have hit any of these walls, Construct is for you.
AI engineers shipping agentic features
You need a runtime where multi-agent patterns are first-class — not assembled from raw API calls and duct tape.
Teams that want auditability
You need the Merkle hash-chain audit log, the per-agent RunLog, and the provenance edges every regulated workflow asks for.
Operators on the edge
You want one Rust binary, on macOS / Linux / Windows / Raspberry Pi, with hardware peripherals as LLM-callable tools.
Builders who refuse to fly blind
You want a live DAG, WebSocket event streams, and tool-call drill-down — not log tail and hope.
Workflows are YAML. The Operator runs them.
Construct workflows are declarative artifacts attached to Kumiho revisions — every save creates a new revision with full diff history. The Operator (Python MCP) drives the DAG through 17 step types and orchestration patterns like supervisor, group_chat, map_reduce, handoff, refinement, and human_approval.
# ~/.construct/workflows/release-notes.yaml
name: release-notes
triggers:
- on_kind: "qs-arc-plan"
on_tag: "ready"
steps:
- id: research
type: supervisor
task: "Investigate the changelog window and gather context"
pool_filter: { capabilities: ["research"] }
- id: draft
type: agent
role: writer
depends_on: [research]
prompt: "Draft release notes from ${research.output}"
- id: review
type: human_approval
depends_on: [draft]
prompt: "Approve before publish?"
- id: publish
type: shell
depends_on: [review]
cmd: "gh release create v${inputs.version} --notes-file ${draft.files[0]}"
Watch the signal propagate.
When a workflow runs, the dashboard becomes a live wiring diagram. Steps shift through pending → running → completed in real time, WebSocket events arrive token-by-token, and every tool call lands in the RunLog you can drill into without leaving the page.
- Interactive DAG graph that breathes — colors shift as the topology executes
- Per-step detail panel: Live Events, Tool Calls, Output
- Per-agent RunLog committed to disk as JSONL
- WebSocket events: agent.started, tool_use, completed, error
Reputation, earned and recorded.
Every agent execution is scored. Trust scores live in Kumiho under Construct/AgentTrust/ — running averages, recent outcomes, and template attribution — and they inform the supervisor pattern's next pick.
Kumiho is the substrate.
Construct stores every namespace as graph items under your tenant. Plans, Goals, Sessions, AgentTrust, Outcomes, Teams, Workflow Runs, and shared Skills — all versioned, all queryable, all linked.
Your phone is the second screen.
Pair a phone or tablet with Construct in one 6-digit code. Once paired, the device gets a tenant-scoped token and live-streams the same dashboard you see on the host — workflow runs, audit chain, agent activity — wherever you are.
- 6-digit code device pairing — issued from /pairing on the host
- Optional WebAuthn hardware keys (--features webauthn)
- Per-device token rotation and revocation from /api/devices
- Approve human-approval gates from the lock screen
- Same WebSocket event stream — no separate mobile build
- Tenant-scoped: a paired phone never sees other tenants
Three things you can ship today
Real patterns from teams running Construct in production.
Release-notes pipeline
A supervisor decomposes the changelog window, a writer agent drafts, a critic loop scores, a human approves, and gh release create runs in a shell step. One YAML, one revision, full history.
Long-running research arc
A planner publishes a qs-arc-plan with tag ready. The reactive graph fires a chain of map-reduce researchers, dedupe, summarize, and tag the final brief — all without a webhook.
Hardware-in-the-loop diagnostics
An on-call agent gets a sensor anomaly via channel webhook, queries the I2C bus through a peripheral tool, files an incident, and notifies the team. Edge I/O speaks the same tool loop as a file edit.
Bring your own LLM. Keep your keys yours.
Construct does not proxy or mark up tokens. Point it at Anthropic, OpenAI, OpenRouter, Ollama, GLM, or any of 14+ providers. Agents the Operator spawns invoke Claude Code or Codex CLI as subprocesses — their existing OAuth handles auth, so your Pro / Codex subscription becomes the spawned-agent runtime.
Ready to build agents that remember?
Construct is open source under MIT or Apache 2.0. The Kumiho free tier gives you 5,000 nodes — real evaluation territory, not a demo cap. The 30-day Studio trial unlocks the moment Construct stores its first memory.