The Autonomic Engine: Routing That Learns Without Burning Tokens

Finance asks why last month’s agent bill looks like every call needed Opus. Engineering shrugs: “We route everything through Sonnet so we don’t mis-classify.” You paid premium rates to decide which model to use — then paid again to do the work.

HUMΛN’s Autonomic Engine inverts that. Classification runs in about 15 milliseconds, uses zero LLM tokens, and produces a typed AutonomicSignal every downstream stage reads. Routing tables built from your org’s real outcomes map task shape to the minimum capable model.

Scroll-stopper: The body does not reason about its heart rate. It regulates it — continuously — using signals already produced for other purposes. That is the model we shipped.

So that capability-first routing is enforced at every human.call() — cost-informed only after capability fit — without burning a classifier LLM on every request.

The problem: Opus rates for Haiku work

Typical enterprise fleet:

• 40% simple lookups, summaries, or formatting
• 20% medium-complexity drafting
• 40% genuinely need large-context reasoning

Uniform Sonnet-class routing overpays the simple majority. “Always biggest model” burns budget on classification-shaped work that never needed it.

The Autonomic Engine reveals task shape once at the human.call() boundary and lets the pipeline reuse that signal.

Classification without an LLM

When a call hits InvocationGateway, AutonomicEngine.classify() runs before Stage 1 of the HumanOS pipeline:

1. Keyword task-shape (ServerClassifier) — fast pattern match
2. Embedding ANN (IntentClassifier) — cosine nearest-neighbor against a pre-built intent index
3. Org overlay — compiled org_intent_indexes can beat global confidence

No chat.completions call. No routing tokens. Output: AutonomicSignal with task_type, complexity, confidence, routing_table_key, novel_shape.

High-confidence signals (confidence ≥ 0.6, novel_shape: false) hit an O(1) table lookup:

routing_table_key = "{task_type}:{complexity}:{budget_preference}"
→ RoutingTableBuilder.lookup() → model_id

Low-confidence or novel shapes fall back to full ANN model selection — still without an LLM in the routing decision itself.

The flywheel

Every classified call writes a routing_decisions row (vectors excluded from provenance inline storage). Four compounding loops:

1. Novel shapes — queue in novel_shapes_pending; after three similar occurrences, promoter adds to the learning index
2. Org index — daily compiler aggregates high-confidence rows into org_intent_indexes
3. Feedback — POST /v1/humanos/routing/:routingId/feedback records wrong-model corrections
4. Table rebuild — when corrections cluster, RoutingTableBuilder rebuilds from quality outcomes

Over weeks, “simple” and “complex” mean what your legal team or support desk actually does — not a generic benchmark.

Command Plane surfaces routing feedback and learning proposals from the same audit trail (routing_decisions rows + feedback endpoint). Operators see org-specific correction clusters and table rebuilds — not a generic model ranking board.

Cost math (illustrative)

Conservative split: 60% of calls are simple/medium that today land on Sonnet-class pricing.

Path	Input $/M (illustrative)	On 60% of 10M tokens/mo
Uniform Sonnet	$3.00	$18,000
Autonomic → Haiku for eligible slice	$0.25	$1,500

Illustrative only: when capability fit allows a cheaper tier, the ratio between Sonnet-class and Haiku-class input pricing on that slice is large. The routing decision itself adds $0 in LLM charges — capability fit still comes first.

On-device: classify before the network

The same embedding family can run on-device in the HUMΛN app. Monthly export compiles the sentence encoder to ONNX, signs it, ships via HotPathBundle.

On device: load signed ONNX → LocalClassifierHint in under 10ms → offline UI hints.

On sync, the server always re-classifies at the gateway. Local hints never bypass delegation or policy — reflex layer’s little sibling, not a shadow router.

When ONNX is unavailable, keyword fallback (confidence: 0.3, novel_shape: true) and the server path pick up the slack. Honest uncertainty, not broken calls.

Canon alignment — Capability-First Routing

HUMΛN’s Principle 9: filter to resources that can do the work; among capable resources, consider cost. The Autonomic Engine enforces that universally at the call level:

• task_type + complexity reveal required capability shape
• routing_table_key selects among capable tiers from audited outcomes
• budget_preference (minimize / optimize / unlimited) applies cost only after capability fit

Magic by default; full override paths for the 10% who need them.

Go deeper

• Product: HumanOS, Command Plane
• Docs: HumanOS concepts, Provenance concepts
• Community: Intent routing architecture, Capability Graph semantic routing, ML risk embeddings