Deep Research: Gliding Horse — When an AI Agent Wears Rust Armor
> Project: Gliding Horse > GitHub: https://github.com/doiito/gliding_horse > Languages: Rust + Go + TypeScript > License: MIT > Positioning: Industrial-grade AI Agent operating system — a trusted autonomous engineering platform
1. The Name Is the Philosophy
The project name references the "Wooden Ox and Gliding Horse" ( Wooden Ox and Gliding Horse), the legendary autonomous supply transports built by Zhuge Liang during the Three Kingdoms era. The analogy maps directly: autonomous transport on treacherous terrain becomes autonomous agent orchestration on complex software engineering tasks; mechanical reliability becomes Rust's memory-safety guarantees.
Gliding Horse positions itself not as an "agent framework" but as an agent operating system: a framework lets you write agents; an OS lets agents run, schedule, audit, and evolve themselves.
2. Core Architecture: Five Operating-System Layers
| Layer | Technology | Role | |-------|-----------|------| | Core coordination | Rust: PDCA cycle, 5W2H ontology, EventBus | Agent orchestration & lifecycle | | Memory system | L0: Sled+Qdrant, L2: Oxigraph, MESI coherence | Layered memory | | Data bus | JSON-LD 1.1, Named Graphs | Universal interop | | Knowledge graph | Oxigraph RDF, SPARQL 1.1, Code AST | Unified cross-subsystem storage | | Skill graph | RDF, 7.5k LOC, self-evolving | Dynamic cognitive network | | Perception engine | 10 triggers, anomaly dedup, 5W2H checks | Proactive monitoring | | Gateway | gRPC, HTTP (OpenAI-compatible), MCP | Production interfaces |
3. Generalized PDCA: From Management Theory to Computation
The Supervisor Agent (SA) dynamically selects a PDCA mode based on 5W2H metadata across seven complexity levels:
- L0 instant tasks — no PDCA
- L1 simple tasks — single-round PDCA
- L2 standard tasks — full PDCA with structured audit
- L3 complex projects — multi-agent parallel Do
- L4 exploratory tasks — parallel Do/Act, divergent strategies
- L5 recursive tasks — subtasks spawn sub-PDCAs
- L6 emergency mode — skip Plan, immediate Do-Check
- Center (Go + Temporal): workflow orchestration, project management, agent registry, graph sync
- Edge (Rust + axum): local LLM execution, Docker sandboxes, VS Code WebSocket bridge
- VS Code plugin (TypeScript): developer UI with real-time agent awareness
- GitHub: https://github.com/doiito/gliding_horse
- Design details:
docs/DESIGN_DETAIL.md - Design philosophy:
docs/CORE_DESIGN_PHILOSOPHY.md - Protocols:
proto/pdca_core.proto - License: MIT
A five-agent pipeline (SA → PA → DA → CA → AA) forms an industrial assembly line with clear responsibilities rather than open-ended multi-agent chat.
4. Memory: CPU Cache Coherence for Agents
A five-tier memory hierarchy:
| Layer | Tech | Latency | Content | |-------|------|---------|---------| | L1 | Context window | Instant | Compressed summaries + IRI pointers | | L2 | Oxigraph in-memory RDF | ~2ms | Task graphs + hypotheses (working blackboard) | | L3 | SPARQL CONSTRUCT + Frame | ~15ms | On-demand subgraphs | | L0 | Sled KV + Qdrant vectors | ~1ms | Full history + embeddings |
The MESI protocol (Modified/Exclusive/Shared/Invalid) is adapted for agent memory: modifications broadcast invalidation, stale references trigger "page faults" to lower tiers. A Prefetch Engine monitors agent intent and preloads knowledge, reportedly reducing perceived latency by ~90% (~2ms vs ~50ms cold load).
5. JSON-LD as a Semantic Bus
Replacing plain JSON with JSON-LD 1.1 solves field-name collisions, missing entity identity, lack of semantic typing, and rigid structure. Six capabilities: @context (duck typing via IRI mapping), @id (global entity identity enabling cross-agent memory fusion without dedup logic), @type (polymorphic discovery), nesting-vs-IRI control (physical token budgets), @graph (conflict-free parallel writes with provenance), and Frame (on-demand shape projection).
A five-level progressive disclosure scheme ranges from ~200-token index scans to full on-demand content, so each agent sees only what it needs.
6. Knowledge Graph + Skill Graph: One Unified Thing
Instead of choosing between vector RAG (fuzzy matching, no structure) and knowledge graphs (exact relations, no fuzziness), Gliding Horse uses IRIs as the universal bridge: Qdrant vector hits return IRIs that trigger SPARQL queries for exact relations, and vice versa — a bidirectional retrieval loop.
The skill graph self-evolves via experience auto-writeback, a /learn mechanism for uncovered problems, a /reduce mechanism distilling solutions into standardized steps, and trust/maturity evolution (experimental → stable → production) tracked with successRate, usageCount, and maturity attributes.
7. 5W2H as Task Ontology
The seven dimensions (What/Why/Who/When/Where/How/HowMuch) are progressively filled across Creation → Planning → Execution → Audit → Archive. The Check Agent performs per-dimension audits (e.g., PASS on all but a WARNING on HowMuch for a 12% token overrun yields CONDITIONAL_PASS), and the Act Agent rolls back precisely: What/Why failures return to SA; How/Where failures return to PA.
8. Security: Code-Level SyscallGate
Security is a runtime hard constraint, not a prompt instruction. Every tool call passes three checks — JSON Schema/SHACL validation, Ed25519 signature verification, and permission-matrix checks — before execution in a Docker sandbox. A perception engine with 10 triggers and 60-second anomaly dedup detects deadline violations, budget overruns (>80% tokens), role mismatches, and environment conflicts, auto-escalating to humans.
9. Center + Edge Federation
The Edge can run offline; there is no single point of failure.
10. Reported Performance
| 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 |
11. Bottom Line
Gliding Horse is not another agent framework. It is a Rust-built platform that ports operating-system design ideas — tiered memory, cache coherence, syscall gates — wholesale into the AI agent world, on the belief that you should not trust an AI's "conscience" but instead engineer hard constraints so it *cannot* misbehave even if it wants to.