An Industrial-Grade AI Agent Operating System Built in Rust
Inspired by Zhuge Liang's Wooden Ox and Gliding Horse — Ancient Ingenuity Meets Modern AI
English ·
中文
Design Detail → An AI agent operating system that orchestrates multiple agents through the PDCA (Plan-Do-Check-Act) cycle. Think of it as the infrastructure layer that harnesses AI agents into a coordinated, auditable, and self-improving system — much like how Zhuge Liang's Wooden Ox and Gliding Horse revolutionized logistics by harnessing mechanical power across treacherous terrain.
"We don't just build agents; we build the
infrastructure that harnesses their collective intelligence."
| Layer | Technology | Role |
|---|---|---|
| Core Coordination (Rust) | ||
PDCA cycle · 5W2H ontology · EventBus |
||
| Agent orchestration & lifecycle | ||
| Memory System | ||
L0: Sled+Qdrant · L2: Oxigraph · MESI coherence |
||
| 5-layer hierarchical memory | ||
| Data Bus | ||
JSON-LD 1.1 · @id/@type/@context · Named Graphs |
||
| Universal interoperability | ||
| Knowledge Graph | ||
Oxigraph RDF · SPARQL 1.1 · Code AST |
||
| Cross-subsystem unified store | ||
| Skill Graph | ||
RDF · 7.5k LOC · Self-evolving |
||
| Dynamic cognitive network | ||
| Perception Engine | ||
10 triggers · Anomaly dedup · 5W2H constraint check |
||
| Proactive monitoring | ||
| Gateway | ||
gRPC · HTTP (OpenAI-compatible) · MCP |
||
| Production interface |
In the turbulent era of the Three Kingdoms (220–280 AD), the legendary strategist Zhuge Liang (诸葛亮), chancellor of the Shu Han state, faced a critical challenge: how to transport supplies efficiently through the treacherous mountain paths of Sichuan during his Northern Expeditions. Traditional wheeled carts struggled on narrow trails; human porters exhausted quickly.
His solution — the Wooden Ox (木牛) and Gliding Horse (流马) — were autonomous transport devices that could navigate difficult terrain with minimal human guidance. These mechanical wonders were not merely tools; they represented a paradigm shift — autonomous systems that extended human capability.
Just as the Gliding Horse served as an intelligent harness for transporting supplies across impossible terrain, Gliding Horse Agent OS serves as an intelligent harness for AI agents:
| Ancient Innovation | Modern Implementation |
|---|---|
| Autonomous Transport | |
| Self-directing agent workflows | |
| Terrain Adaptation | |
| Dynamic complexity handling (7 levels) | |
| Load Distribution | |
| Parallel agent execution | |
| Minimal Guidance | |
| Proactive anomaly detection | |
| Mechanical Reliability | |
| Rust's memory safety guarantees |
"The wise adapt their methods to circumstances, just as water shapes its course according to the ground over which it flows."
—Zhuge Liang
This ancient wisdom guides our design: flexible orchestration that adapts to task complexity, rather than rigid frameworks that force tasks into predefined molds.
The Software Engineering Team app demonstrates the full power of Gliding Horse — a federated architecture where multiple AI agents collaborate on real-world software engineering tasks.
Center dashboard — project oversight, agent status, pipeline progress
Project lifecycle managementfrom req → design → code → review → deploy | Multi-stage SDLC pipelinewith real-time status tracking |
VS Code Plugin — chat panel, graph view, and task panel for real-time agent collaboration
flowchart TB
subgraph VS["VS Code Plugin (TypeScript)"]
direction LR
CHAT["Chat Panel"]
GRAPH_V["Graph View"]
TASK_P["Task Panel"]
end
subgraph EDGE["Edge Daemon (Rust · axum)"]
API_EDGE["API Server<br/>ws / chat / health"]
AGENT_CORE["Agent Core<br/>SupervisorAgent · DoAgent · LLM Client"]
DOCKER["Docker Sandbox<br/>Safe execution · Compile / Test"]
SYNC_EDGE["Sync Layer<br/>Heartbeat · gRPC · JWT Auth"]
GRAPH_EDGE["Graph Layer<br/>Local Store (sled) · Delta Sync"]
API_EDGE --- AGENT_CORE
AGENT_CORE --- DOCKER
API_EDGE --- SYNC_EDGE
AGENT_CORE --- GRAPH_EDGE
end
subgraph CTR["Center (Go · Gin)"]
API_CTR["HTTP API<br/>/api/v1/* · /ws"]
TEMPORAL["Temporal Workflow<br/>Orchestrator"]
AGENT_MGR["Agent Manager<br/>Register · Heartbeat · Dispatch"]
EXEC["Executors<br/>req → design → coding → review → test → cicd → deploy"]
STORE_CTR["Store<br/>SQLite · gRPC Client · Graph Sync"]
API_CTR --- TEMPORAL
API_CTR --- AGENT_MGR
TEMPORAL --- EXEC
AGENT_MGR --- STORE_CTR
end
VS <-->|"WebSocket / REST"| EDGE
EDGE <-->|"gRPC + REST"| CTR
Key Design Patterns:
Center (Go): Workflow orchestration via Temporal, project CRUD, agent registry, graph sync** Edge (Rust): Local LLM execution, Docker sandbox, VS Code WebSocket bridge VS Code Plugin**: Developer UI with real-time agent awareness
Gliding Code is a terminal-based AI coding assistant that brings the power of Gliding Horse's knowledge graph and agent orchestration directly into your command line — no IDE required.
Knowledge graph visualization — real-time entity relationships, code structure understanding, and cross-subsystem awareness powered by Oxigraph RDF
Task completion interface — AI agent successfully analyzing and solving a programming task with full traceability
Choose your path — download and run the pre-built terminal AI assistant (zero dependencies), or build from source for the full Software Engineering Team.
No dependencies required. Just download, extract, and run:
| Platform | Download |
|---|---|
| Linux (x86_64, musl) | |
glidingcode-x86_64-unknown-linux-musl.tar.gz |
(12.9 MB)glidingcode-aarch64-unknown-linux-musl.tar.gz
(12.1 MB)glidingcode-aarch64-apple-darwin.tar.gz
(11.6 MB)glidingcode-x86_64-pc-windows-msvc.zip
tar xzf glidingcode-*.tar.gz
./glidingcode --help
Expand-Archive glidingcode-x86_64-pc-windows-msvc.zip .
.\glidingcode.exe --help
All Linux builds are
fully statically linked(musl) — no runtime dependencies required.
Set your API key and start using it:
export DEEPSEEK_API_KEY="sk-..." # Linux / macOS
set DEEPSEEK_API_KEY="sk-..." # Windows (cmd)
$env:DEEPSEEK_API_KEY="sk-..." # Windows (PowerShell)
export AGENT_OS_GATEWAY_API_KEY="sk-..."
export AGENT_OS_GATEWAY_API_URL="https://your-endpoint/v1"
./glidingcode
./glidingcode "Explain how Rust's borrow checker works"
Build the complete multi-agent system from source (requires Rust + Go + Docker).
Rust 1.75+ ·Go 1.25+ ·Docker·** Temporal Server**- LLM API key (OpenAI-compatible)
git clone https://github.com/doiito/gliding_horse.git
cd gliding_horse/apps/software_engineering_team
cp center/config.yaml center/config.local.yaml
cd center
go run ./cmd/server/... # API server on :8080
go run ./cmd/worker/... # Temporal worker
cd edge/daemon
cargo run -- daemon start # Agent daemon on :7890
Install the plugin from edge/vscode/
and connect to the daemon — you now have an AI software engineering team at your fingertips.
curl http://localhost:8080/api/v1/projects \
-X POST -H "Content-Type: application/json" \
-d '{"name":"My Project","description":"Build a microservice"}'
Generalized PDCA — 7-Level Adaptive Execution
Dynamically selects from 7 complexity levels (L0 instant → L5 recursive → L6 emergency) via 5W2H metadata. One engine handles everything from instant queries to multi-week projects — no rigid workflows. - CPU Cache-Inspired Memory — 5 Layers + MESI Coherence
First-ever application of CPU cache coherence to multi-agent memory. L0 disk → L1 context → L2 Oxigraph RDF → L3 SPARQL projection. Intelligent prefetching reduces perceived latency by 90%. Solves context explosion and shared memory inconsistency. - JSON-LD Universal Data Bus — W3C-Standard Interoperability
@context
duck-typing eliminates field name conflicts between skills.@id
enables zero-cost cross-agent entity merging.@graph
named graphs allow conflict-free parallel writes. Turns interoperability hell into plug-and-play. - Self-Evolving Skill Graph — Cognitive Network
7,500+ LOC dynamic network with 6 semantic link types (Prerequisite, Composition, Related, etc.). AA creates knowledge fragments and new links after each task./learn
and/reduce
mechanisms enable autonomous skill acquisition. - Universal Knowledge Graph — Unified Cognitive Backbone
All subsystems (skills, memories, tasks, code knowledge) share a single Oxigraph RDF store via named graphs, enabling cross-subsystem SPARQL joins. Code ASTs parsed by tree-sitter are automatically converted to RDF triples and linked into the same graph. A single@id
ensures consistent entity identity across all contexts — no silos, no duplication. - 5W2H Dimension-Level Audit — Precision Rollback
CA audits each of the 7 dimensions independently. What/Why fail → re-analyze. How/Where fail → re-plan. When/HowMuch fail → conditional pass. No more black-box "PASS/FAIL" — you know exactly what went wrong. - Proactive Perception Engine — Catch Failures Before They Happen
10 execution triggers with 60-second anomaly deduplication. Monitors deadline violations, budget overruns (>80% tokens), role mismatches, environment conflicts. Auto-escalates to human when needed. - Micro-Tool System — Tame Large Outputs
Results >8KB auto-generate conversational micro-tools (e.g., "search_in_results"). Transforms unwieldy 50KB+ outputs into interactive, queryable artifacts within the LLM context. - MCP Integration — One Protocol to Connect Them All
Standard Model Context Protocol connects GitHub, Slack, Jira, and any MCP-compatible server. Dynamic tool discovery at runtime. No more custom integrations for every external service. - Checkpoint & Recovery — Crash-Proof Long-Running Tasks
Session state snapshots at critical points. Full restoration on crash without context loss. Enables hour/day-long agent tasks and post-mortem replay debugging. - Center + Edge Federation — Local Autonomy, Global Orchestration
Go Center handles workflow orchestration (Temporal), project management, agent registry. Rust Edge runs local LLM execution with Docker sandbox. VS Code Plugin provides real-time developer awareness. No single point of failure.
Core OS (ongoing):
- Enhanced MCP tool ecosystem and dynamic discovery
- Multi-model routing optimization with cost-aware scheduling
- Knowledge graph query performance and scale improvements
- Template engine with versioned prompt inheritance
- Rich event system with fine-grained subscription filters
Application Layer (upcoming):
Q3 2026: Native web dashboard for agent monitoring and task management; Python/TypeScript SDK for easier integration** Q4 2026**: Kubernetes deployment operator; Multi-turn conversation memory compression; Skill marketplace prototype** 2027**: Distributed agent mesh across Edge nodes; Multi-modal agent support (vision, audio); Community plugin registry
| Operation | Latency | Throughput |
|---|---|---|
| L2 Node Write (Oxigraph) | ~2ms | 500 ops/sec |
| L3 SPARQL Projection | ~15ms | 66 ops/sec |
| L0 Sled KV Read | ~1ms | 1000 ops/sec |
| Agent ReAct Turn | 1-5s | 0.2-1 turns/sec |
| Idle Memory | ||
| ~200MB | scales with tasks |
Design Detail→·docs/DESIGN_DETAIL.md
(中文)docs/DESIGN_DETAIL.zh.md
Core Design Philosophy→·docs/CORE_DESIGN_PHILOSOPHY.md
(中文)docs/CORE_DESIGN_PHILOSOPHY.zh.md
gRPC Proto→proto/pdca_core.proto
Specs→spec/
We welcome contributions from the community!
🐛 Report bugs:GitHub Issues💡 Propose ideas:GitHub Discussions🔀 Submit PRs: Fork → feature branch → PR againstmain
git checkout -b feat/my-feature
cargo fmt && cargo clippy # Keep code clean
cargo test # Ensure nothing breaks
git commit -am 'Add my feature'
git push origin feat/my-feature
All contributors are expected to adhere to our Code of Conduct.
MIT License — see LICENSE.