The Autonomic Engine: Routing That Learns Without Burning Tokens

Every LLM platform has the same hidden tax: you pay premium model rates to decide which model to use, and then you pay again to do the work. Worse, most platforms route everything through the same mid-tier model because configuration is hard and defaults are lazy.

HUMΛN's Autonomic Engine inverts that. Classification runs in about 15 milliseconds, uses zero LLM tokens, and produces a typed AutonomicSignal that every downstream stage reads. Routing tables built from your org's real outcomes map task shape to the minimum capable model. The system gets sharper as you use it — not through a generic fine-tune, but through an org-specific flywheel fed by your own audit rows.

The problem: Opus rates for Haiku work

Consider a typical enterprise agent fleet:

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

If you route uniformly to a Sonnet-class model ($3/M input tokens), you overpay on the simple majority. If you route everything to the biggest model "to be safe," you burn budget on classification-shaped work that never needed it.

The Autonomic Engine's job is to reveal task shape once at the human.call() boundary and let the pipeline reuse that signal — so model selection is capability-first and cost-informed, not guesswork.

Classification without an LLM

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

Keyword task-shape (ServerClassifier) — fast pattern match for coding, calendar, email, etc.
Embedding ANN (IntentClassifier) — cosine nearest-neighbor against a pre-built intent index
Org overlay — if your org has a compiled org_intent_indexes table, org confidence can beat global

No chat.completions call. No routing tokens. The output is an AutonomicSignal with fields like task_type, complexity, confidence, routing_table_key, and novel_shape.

High-confidence signals (confidence ≥ 0.6, novel_shape: false) hit an O(1) routing 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 with the signal attached (vectors excluded from provenance inline storage). That audit trail powers four compounding loops:

Novel shapes — low-confidence patterns queue in novel_shapes_pending; after three similar occurrences, a promoter adds them to the learning index
Org index — daily compiler aggregates high-confidence rows into org_intent_indexes for your org_did
Feedback — POST /v1/humanos/routing/:routingId/feedback records wrong-model corrections
Table rebuild — when corrections cluster on a key, RoutingTableBuilder rebuilds the precomputed table from quality outcomes

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

Command Plane will show flywheel health as:

Your org classifier: 847 patterns learned, last updated 2026-06-28

That single line is the operator-facing proof the system is learning.

Cost math

Take a conservative split: 60% of calls are simple or medium complexity 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

That's roughly a 12× reduction on the affected calls — not a marketing rounding exercise, but the direct ratio between tiers when routing_table_key resolves correctly.

The routing decision itself adds $0 in LLM charges. At billions of calls, shaving even one mini-classifier invocation per request is material; eliminating it entirely is the design goal.

On-device: classify before the network

The same embedding family that powers server-side ANN can run on-device in the HUMΛN app (apps/human-app). A monthly export pipeline (onnx-model-exporter) compiles the sentence encoder to ONNX, signs it, and ships version metadata via HotPathBundle.

On device:

Load signed ONNX artifact
Produce a LocalClassifierHint in under 10ms
Use offline for UI hints and diagnostics

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

When ONNX is unavailable, the client degrades to keyword fallback (confidence: 0.3, novel_shape: true) and the server path picks up the slack. No broken calls, just honest uncertainty.

Canon alignment — Capability-First Routing

HUMΛN's Principle 9 (Capability-First Routing) says: filter to resources that can do the work; among capable resources, consider cost. The Autonomic Engine is how that principle is enforced 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 pressure only after capability fit

You do not configure this per agent for the common case. Magic by default; full override paths exist for the 10% who need them.