Back to articles

Orión: A Tier-Routing Philosophy for Personal AI Orchestration

This isn't a "my side project beats serious products" article. It's a case study in a specific philosophy — cheap router, scoped workers, durable memory, nothing blocking — compared honestly against two mature projects that cover overlapping ground: Hermes from Nous Research and OpenClaw.

Over the last few weeks I installed Hermes, Nous Research's open-source agent, and tried OpenClaw, an MIT ecosystem with significant GitHub traction focused on 24/7 multi-channel personal agents. Both cover part of the problem I'd already solved at home with Orión, my personal orchestrator. I wanted to understand what they did better than me, what they did differently, and which parts of my design held up under scrutiny.

Short conclusion: Hermes is technically impressive on parallelism and sandbox diversity. OpenClaw is brutal on messaging channel coverage and ecosystem maturity (Foundation, skills marketplace, companion apps). Orión's real differentiator isn't raw feature surface — it's a concrete philosophy of cost-aware routing that no generalist product implements by default. This article explains that philosophy without inflating the comparison table.

The core problem: mono-tier agents

Most agent orchestrators — Hermes and OpenClaw included in default configuration — assume a single model handles every request. OpenClaw supports multi-provider with automatic failover on rate-limit, but the selection is still manual. Hermes lets you configure the model. Neither implements automatic cost-aware tier routing.

That's expensive by design. A routing question costs the same as a deep reasoning question. A greeting costs the same as a migration plan. And because everything goes through one pipe, latency compounds.

Mono-tier agents are tractors with one gear. They work, but you always pay for maximum torque even when crawling in a parking lot.

Orión's 3-tier architecture

Orión runs three model tiers, each with a specific mandate:

Tier 1 — Haiku: the front-line router

Every message lands here first. Haiku is fast (sub-second response for simple queries) and costs a fraction of Sonnet or Opus. The router's job is a decision tree, not heavy reasoning:

• Can I answer this directly? (greetings, factual queries, status checks) → answer inline.
• Does this need file access, code execution, or project-specific work? → delegate to a Sonnet worker, return an acknowledgement immediately.
• Is this architectural, complex, or explicitly marked as "think deeply"? → escalate to Opus, return acknowledgement, notify when done.

The key insight: the router never blocks. If it delegates, the user gets a confirmation in milliseconds. The heavy work happens async.

Tier 2 — Sonnet: project workers

Each project gets its own Sonnet worker session. Workers are persistent — a follow-up question in the same project resumes the existing session instead of starting cold. Workers can read files, execute shell commands, write code, run linters, check service logs — anything scoped to their project.

Multiple workers run in parallel. If you need work done on three different projects simultaneously, three Sonnet sessions run concurrently while the Haiku router is free to handle new messages.

Tier 3 — Opus: escalation for depth

Opus sessions are ad-hoc and expensive by design. Reserved for decisions that justify the cost: system architecture, migration planning, complex debugging, technical trade-off analysis. Opus is invoked async — results land as a notification, not as a blocking wait.

Key capabilities

An honest comparison with Hermes and OpenClaw

Before the table, a fair characterization of both projects. I read their public documentation and tried them briefly; what follows is what they actually do — not the strawman version designed to inflate my project.

Note: OpenClaw runs one task per session at a time (serialized to avoid race conditions). Parallelism comes from multiplying instances per channel/workspace, not from concurrent subagents inside one session like Hermes. It's a design trade-off: simplicity and predictability over raw parallelism.

Capability	Orión	Hermes	OpenClaw
Cost-aware tier routing	Explicit (Haiku → Sonnet → Opus)	Manually configurable	Manual + automatic failover
Async delegation	Native non-blocking	NL cron + serverless hibernation	Persistent 24/7, 1 task/session serialized
Durable memory	Qdrant RAG cross-session	Local FTS5 + Honcho profiles	Local SQLite + vector embeddings
Parallel subagents	1:1 Sonnet workers per project	Concurrent RPC subagents	1 task/session serialized
Sandbox backends	Local only	5 (local/Docker/SSH/Singularity/Modal)	3 (host/Docker/SSH/OpenShell)
Messaging channels	Discord (Node bridge) + optional Telegram	6 native (TG/Discord/Slack/WA/Signal/Email)	20+ native (incl. iMessage, Teams, Matrix, LINE, WeChat)
Native voice	Discord voice channel duplex (Groq STT + Edge TTS + ambient + queue)	Not native	ElevenLabs + macOS/iOS companion with push-to-talk
Natural-language cron	Yes (APScheduler + MCP tool)	Yes, built-in	Cron tool, NL not confirmed
Reusable skills	Manual markdown catalog (v1) — auto-gen on roadmap	Auto-generated by the agent	Manual + ClawHub marketplace
Image generation	gpt-image-2 (AI Fabric) → direct Discord post	N/A	Via external plugin
Model flexibility	Anthropic + AI Fabric LiteLLM failover	200+ models any provider	Multi-provider + failover (Claude/GPT/DeepSeek/local)
Maturity / ecosystem	Personal, not public	Research project, active community	Strong ecosystem with Foundation governance + commercial plugins
License	Personal / not released	MIT	MIT (Foundation governance)
Monthly cost	Pay per use, tier-optimized	Self-hosted (infra + API only)	Self-hosted free (BYOK) or third-party SaaS (Clowdbot, etc.)

Honest read of the table:

• Orión wins on a single clear axis: automatic cost-aware tier routing. The others support it manually or not at all.
• Hermes wins on subagent parallelism + sandbox diversity (5 execution backends + 2 serverless hibernation targets) + 200+ models + auto-generated skills.
• OpenClaw wins on channel coverage (20+ native messengers) + voice + companion apps + ecosystem maturity (Foundation, marketplace, thousands of contributors).
• Orión loses on breadth: Discord-centric, local only, no skills marketplace, no Foundation. That's deliberate — it's a personal project, not a product.

Real usage examples

Example 1 — Direct reply (Haiku inline)

User: "What projects are running right now?"

Haiku calls list_projects(), formats the response, replies in under a second. No worker, no delegation. Cost: one Haiku inference.

Example 2 — Async delegation (Sonnet worker)

User: "In the server project, restart the monitoring stack and check for errors in the last 100 log lines."

Haiku identifies project, calls delegate_to_project("server", prompt), returns ack immediately. Sonnet worker executes shell, analyzes logs, pushes Discord notification (text + voice channel narration) with findings. User gets ack in milliseconds and result a minute later — no terminal waiting.

# Router decision (pseudocode)
intent = classify(user_message)
# → "project_action" on project="server"

delegate_to_project(
  project="server",
  prompt="Restart monitoring stack. Check last 100 log lines for errors. Report."
)
# returns immediately

ack_user("On it — I'll notify you when done.")

Example 3 — Opus escalation (deep architecture)

User: "Think carefully about migrating our n8n workflows to a native agent architecture. Consider costs, maintenance and rollback."

"Think carefully" + strategic nature triggers escalation. Haiku calls escalate_to_opus(prompt), returns ack, continues handling other messages. When Opus finishes (5–15 min), notify_user pushes a summary with full analysis available on-demand.

Example 4 — Memory recall across sessions

User: "What did we decide about the database schema last week?"

Before answering, the system injects top-K hybrid memories (Qdrant + FTS5 fused via RRF). Exact match of "database schema" + semantic similarity surfaces the decision even if stored with different wording: remember("DB schema: UUID primary keys over auto-increment for cross-service portability", tags=["db", "schema"]).

Example 5 — Instant skill (no Sonnet)

User: "How much Anthropic quota do I have left?"

Haiku searches skill catalog → finds claude-quota → invokes invoke_skill("claude-quota", {}) → runs Python script against Anthropic API with OAuth Bearer → returns JSON with 5h/7d utilization. Latency <1s. Zero Sonnet/Opus cost.

Example 6 — On-demand image generation

User in Discord voice channel: "Orion, generate an image of an astronaut cat on Mars"

Haiku decides → generate_image("an astronaut cat on Mars", "1024x1024") → POST to AI Fabric gpt-image-2 → 2MB PNG → bridge uploads as direct Discord attachment. 60-180s latency, during which the ambient pad plays. Caption inline with the prompt.

Example 7 — Recurring scheduling

User: "Every Monday at 9 tell me the status of server services"

Haiku translates to cron → schedule_recurring("invoke skill list-services and report", "0 9 * * 1", label="monday-services"). APScheduler persists the job. Every Monday 9:00 it fires, executes as autonomous Orion turn, calls invoke_skill("list-services"), narrates the result with notify_user direct to Discord.

Example 8 — Transparent failover

Anthropic returns 429 (Max limit hit). Master Haiku retries 3 times with exponential backoff. If still failing, automatic fallback to AI Fabric LiteLLM (Claude same model, different provider). Degraded mode: text only, no tools. User notices slightly higher latency but NO interruption. Metric orchestrator_turn_fallback records the event — visible via /errors.

The cost arithmetic

Official Anthropic pricing May 2026 ($/M tokens):

Model	Input	Output
Haiku 4.5	$1.00	$5.00
Sonnet 4.6	$3.00	$15.00
Opus 4.7	$5.00	$25.00
gpt-image-2 (AI Fabric)	~$0.07 / 1024² image

Note: the 4.5/4.6/4.7 generation cut Opus from $15/$75 (that was Opus 4/4.1) down to $5/$25 — a 67% reduction that materially changes the economics of premium-tier reasoning.

A typical day modeled (~200 turns):

Interaction type	Orión cost	Mono-tier Sonnet (no routing)
~150 Haiku queries (routing, status, chitchat)	~$0.13	~$1.50
~40 Sonnet worker tasks	~$0.30	~$0.30
2 Opus escalations (planning)	~$0.27	~$0.20 (worse quality)
Edge TTS + Groq STT (voice channel)	$0 (free tier)	$0
Image gen (2 images / day)	~$0.14	N/A
Total / day	~$0.84	~$2.00 (worse on deep work, same TTS/STT)

Subtlety: most of the saving comes from routing ~75% of turns to Haiku at a fraction of Sonnet cost. With current Opus pricing (much cheaper than the previous generation), escalating to Opus for deep planning barely moves the needle on cost. The Orión advantage isn't raw price — it's the automation of tiering: it does it by default, without you thinking about it. And for deep analysis, Opus delivers quality Sonnet can't match — now at a very reasonable cost.

You don't pay for standing capacity. You pay for actual work done at the tier that work requires.

How Orión can improve — lessons from the competition

Evaluating Hermes and OpenClaw seriously revealed areas where Orión falls short and which enter my near-term roadmap. I don't call these "things Orión already has". I call them "technical debt I recognize".

Orión roadmap — updated status

Update May 2026: most of the Q2-Q3 roadmap landed in an intensive sprint. What follows reflects actual state.

What Orión doesn't replace

OpenClaw is clearly the best option if your priority is channel coverage (you want to talk to your agent from WhatsApp, iMessage, Signal and Telegram depending on the moment), mature ecosystem with commercial plugins (CloudBot.ai voice, Claworc multi-instance), native macOS/iOS companion apps, or you need an MIT project with Foundation governance for sustainable professional use.

Hermes is excellent if you need real subagent parallelism with diverse sandboxes (Docker/SSH/Modal/Daytona), 200+ multi-provider models in the same pipeline, agent-generated auto-skills, or out-of-the-box serverless hibernation.

Orión fits a different profile: a technical operator who already runs their own infra, wants full control over per-interaction cost (hence the tier-routing), prefers a pure Anthropic stack with optional failover, and is willing to invest days of setup to have an orchestrator shaped to their personal flow, not to a generic use case. If those profiles don't fit, OpenClaw or Hermes are better options, and that's fine.

Closing thought

This article isn't meant to replace or outdo Hermes, OpenClaw, or any other serious product in the ecosystem. Hermes is technically excellent. OpenClaw is a reference for maturity. Either can be the right choice for a lot of people, and I have no ambition to compete with them on breadth, ecosystem, or community traction.

What this article is meant to do is defend a simple idea: anyone with interest and time can build their own personal agent. You don't have to wait for a generalist product to cover your exact use case. You don't have to delegate every decision to third-party code whose implementation you don't understand. You can pick your stack, your models, your channels, your memory, your tone — and modify any of them the moment something feels off.

Cost-aware routing is one concrete example. Owning your own RAG memory with the semantics you care about is another. Deciding which messaging channel you use, which voice replies, which pre-recorded ack you hear while the model thinks — dozens of small decisions no generalist product is going to nail exactly to your taste. Building it yourself means every choice is conscious, and when something breaks you know exactly where to look.

There's a cost: setup time, maintenance, accumulated tech debt. I take that cost because I care about understanding what sits under each layer of the software I use most. It's not for everyone, and that's fine. But if you've ever wondered what exactly happens when you press a button on that SaaS you depend on, that curiosity alone is enough reason to start building.

Building your own orchestrator isn't competing with serious products. It's exercising conscious control over the tool you use most every day — and discovering, along the way, just how much you can do yourself.

---

Back to articles