Show HN:Gliding Horse – a Rust Agent OS with CPU-Like Memory Architecture

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."

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:

"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 management from req → design → code → review → deploy

Multi-stage SDLC pipeline with real-time status tracking

VS Code Plugin — chat panel, graph view, and task panel for real-time agent collaboration

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:

# Linux / macOS
tar xzf glidingcode-*.tar.gz
./glidingcode --help # Windows (PowerShell)
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
# or
set DEEPSEEK_API_KEY="sk-..." # Windows (cmd)
# or
$env:DEEPSEEK_API_KEY="sk-..." # Windows (PowerShell) # Alternatively, use any OpenAI-compatible provider:
export AGENT_OS_GATEWAY_API_KEY="sk-..."
export AGENT_OS_GATEWAY_API_URL="https://your-endpoint/v1" # Run an interactive session (Linux/macOS: ./glidingcode, Windows: .\glidingcode)
./glidingcode # Or run a one-shot task
./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
# Edit your LLM keys, Temporal host, etc.

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"}'

1. 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.

2. 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.

3. 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.

4. 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.

5. 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.

6. 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.

7. 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.

8. 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.

9. 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.

10. 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.

11. 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

We welcome contributions from the community!

git checkout -b feat/my-feature
# Make your changes
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.