Design spine

OpenClaw was an early, important attempt to put open-source agentic power in reach of everyone. Building on that lineage, we kept hitting a structural gap: designs that assume one agent does everything do not line up with how real work is split—teams, parallel roles, and handoffs.

GitS starts from many agents with clear roles, composed from data and files rather than a single monolithic mind. The stack is meant to be live (hot reload), lightweight (goroutines, not one container per agent), and well-crafted (clean boundaries between engine, authored material, and extensions).

The Ghost engine is implemented in Go with a parallel-process architecture tuned for throughput—enough headroom to run on the order of 10k agents on one node when the workload fits (I/O, scheduling, and world layout permitting).

An agent is an autonomous actor with personality, purpose, and rules. Everything goes through named tools, with syscalls to the control plane where needed. That pairing—agent × tool—is the foundation the rest of the system assumes.

In GitS, system call names a pair of surfaces: authored system (markdown archetypes—soul, goals, laws, prompts) and machine config (config.md, world YAML, privilege lists). The machine half is the system-call boundary—it gates which syscalls (syscall.*) hit the control plane. The authored half is what the model reads. Together they let an agent describe its world and invoke the engine through system calls, not a single hard-coded loop.

Knowledge is how agents exchange durable learning inside a world: shared entries with explicit ACL, separate from private per-agent memory. It is one of the loosely coupled pieces that make a multi-agent graph describable without shared mutable code.

With agents, tools, the system-call pairing, and knowledge kept loosely coupled, you can describe who works with whom, which capabilities apply, and how a world runs—from manifests and markdown, loaded at runtime and hot-reloaded. The world’s rules and roster are data, not a fixed program: nothing fundamental requires a compile step to change the world loop.

The agent loop borrows the spirit of Ghost in the Shell: on each tick, a small LLM step—Ghost Whisper—decides whether to wake for full think–act–observe work, stay asleep, or exit. When the agent is informed but not in heavy execution, Whisper also fits background duties such as memory consolidation. Whisper nudges the agent; together with the main loop, it is how the fleet stays intentional instead of blindly polling.

On top of the core: tasks so external systems can see work split across agents; channels (WebSocket, Slack, world channel for agent↔agent chat); skills as instruction bundles (same idea space as OpenClaw-style skills); DSL and snippets for structured manifests; workspace layout and Git-style tooling; plus secrets, scheduler / clock-driven wake, and other operational hooks.

• Tasks & API (api.md, tools.md syscall.task.*)
• Channels
• Skills
• DSL & snippets
• Workspace · Git tooling
• Secrets & syscalls · Scheduler