Scion Core
A five-part containerized orchestration system for multi-agent workflows.
Define
Agent Templates
Run
Sandbox Runtimes
Spawn
Swarm Hierarchies
Notify
Reactive Wakeups
Sync
Shared Filesystem
Agent Definition
In Scion, an agent is defined by a structured template consisting of four core layers.
1. System Instruction
A system instruction defining the agent's primary purpose, persona, and core role. Configured as the foundational LLM boundary.
2. Agent Instructions
Detailing how the agent gets its work done. Scion dynamically appends contextual instructions based on its workspace.
3. Agent Skills
A set of specialized skills conforming to the Agent Skills Specification to perform deterministic CLI tasks.
4. Model Context Protocol (MCP)
Optionally configures MCP server connections to dynamically expose external tools, with container harnesses as optional execution details.
Agent Runtime
Scion abstracts complex system execution, managing secure, isolated processes across varied backends under a managed control plane.
- Agent Lifecycle: Uniform control commands (
create,start,stop,attach,delete) regardless of the underlying agent implementation. - Container Runtimes: Seamlessly executes sandboxed processes across Docker, Podman, macOS native Apple Virtualization, or remote Kubernetes.
- Env & Volume Mounts: Projects explicitly defined environment variables, mounts read-only secrets/credentials, and maps isolated
tmpfsshadow volumes. - Native & Federated Identity: Binds native project-scoped identities to federated systems like GCP service accounts or Agent Platform credentials.
Agent Collaborators
Scion supports teams of humans working with teams of agents. Both are treated as actors in the system, enabling dynamic, self-directed collaboration instead of rigid, hard-coded orchestration graphs.
- Actor Interaction: Both humans and agents can query, message, or inspect Agents.
- Self-Directed Management: Agents are equipped with access to the
scionCLI, letting agents themselves dynamically spawn, query, or stop sub-agents. - Asynchronous Messaging: Collaborators communicate asynchronously, sending messages and delegating work across safe, pluggable brokers.
- Interactive Inspection: Humans and parent agents can attach or "look" at running agent processes (via
tmux) or view logs.
Agent Notifications
Scion combines state and messages into notifications to provide robust asynchronous event driven orchestration patterns.
- State & Message Intersection: Notifications represent events triggered when an agent transitions state (e.g. from
workingtowaiting_for_input). - Sub-Agent Suspend Pattern: When an agent delegates a task, it invokes a child, updates its activity to
blocked, and sleeps. No active polling occurs. - Event-Driven Wakeup: Once the sub-agent completes, stalls, or needs input, a notification hook automatically wakes the parent agent up.
- Human Attention Alerts: Triggers notifications to Slack, terminals, or dashboards the instant an agent gets stuck or requires human confirmation.
Shared Filesystem
For multi-agent workflows, sharing a high-performance filesystem provides frictionless code modification, test execution, and file exchanges. Scion manages concurrent file access safely.
- Shared File Volume Mounts:
- Agent workspaces share the same physical project directory, avoiding heavy git clone replication delays and preserving disk space.
- Pass Context by Reference:
- Instead of bloating LLM payloads with massive files or logs, agents pass a file path reference on the shared volume, drastically saving token bandwidth.
- Shared Learnings & Progress Notes:
- Sibling agents read and write shared folders to exchange progress summaries and execution logs in real time.
- Workspace Branch Isolation:
- If Git isolation is needed, agents can initialize local branches or isolated worktrees, but they still operate on the shared disk storage.
Scion Orchestration Review
From declarative template definitions to secure, low-latency filesystem execution, Scion coordinates complex agentic workflows in five key stages.
1. Define
Parses declarative agent templates containing system instructions, prompts, custom skills, and MCP configurations.
2. Run
Launches standard execution sandboxes, isolating credentials, variables, and runtime boundaries dynamically.
3. Spawn
Coordinates human actors and P2P agent hierarchies with lateral peer-to-peer messaging brokers.
4. Notify
Enforces reactive wakeup sleep cycles (suspends parent, wakes instantly on child completion notification).
5. Sync
Shares folder filesystems concurrently to pass large context by reference and exchange shared progress notes.