Complexity-based routing tiers (simple/standard/complex/reasoning) not exposed in self-hosted Beta dashboard

[csmwebdesign]

Summary:
The docs (/docs/routing#complexity) describe automatic complexity routing — Manifest scores every manifest/auto request across 23 dimensions and buckets it into one of four system tiers: simple, standard, complex, reasoning. Each tier is supposed to map to its own primary model + fallback chain in the dashboard. This routing type doesn't appear anywhere in the self-hosted Beta UI we're running.
What we see instead:
The harness Routing tab (Harnesses → [agent] → Routing) only exposes two routing types:

Default — single fallback-chain tile, used when no other rule matches
Custom — via "Manage custom routing" modal → "Create new tier", which only supports header-based tiers (name, Header key/Header value pair, badge color, stream mode)

There's no tile, toggle, or section for the four named complexity tiers anywhere in Routing, Providers, Limits, or Settings on the harness page.
Question for the team:
Is complexity-based routing (a) not yet implemented in this self-hosted build, (b) gated behind a flag/toggle we haven't found, or (c) planned to surface as system-reserved tier names (e.g. typing simple into "Create new tier" specifically) rather than being auto-created?

Impact:
Without complexity routing, we can't route manifest/auto traffic automatically by difficulty — we're currently working around it with manually-tagged x-manifest-tier headers sent per-request from OpenClaw instead, which requires OpenClaw-side logic to decide simple vs. complex rather than letting Manifest's scorer handle it.

[jonasbareiss]

Having the same Issue with the cloud version on new sign-up as well.

[klausnitsche]

This looks like the (intentional) behaviour described here: https://manifest.build/blog/deprecating-rule-based-routing/

I have used Manifest's complexity routing with Hermes and it worked pretty well for me. Too bad they're deprecating it.
If anyone knows of another routing solution that can do this, I'm interested.

[jonasbareiss]

Yeah, just found that blog post digging through the CLAUDE.md as well. Lets see if we can build a small router in hermes that sets the headers

[zunami]

I've been using Manifest's Auto Mode (simple/standard/complex) since day one, and it was a game changer – especially when running Hermes Agent as my main harness.

Here's why it was so crucial: Hermes works through long, multi-step workflows autonomously. It goes step by step, making decisions, running tools, analyzing results – sometimes dozens of turns in a single session. And in those workflows, different steps have very different complexity needs. A simple data lookup needs Standard (or even Simple). A critical reasoning step needs Complex. A code analysis might need Reasoning.

With Auto Mode, Manifest handled this automatically. Hermes just worked, and Manifest picked the right model for each step based on what the query actually needed. I didn't have to constantly micromanage and manually switch models between steps. The agent did its thing, and the routing just worked in the background. Costs saved, quality maintained.

That's exactly why the removal hurts so much. The suggested workaround – sending x-manifest-tier headers manually from the client – completely misses the point. I can't look into Hermes' autonomous workflow and decide at every single turn "this is Complex, this is Standard". That's the whole reason I use an autonomous agent in the first place – so I don't have to micromanage every step.

The blog post says rule-based routing had "mixed results" because large system prompts (like Hermes) classify everything as complex. But honestly? I was fine with that. Even when some queries were over-classified, the cost savings from the correctly routed ones still made it worth it. And the alternative – no automatic tier selection at all – is a huge step backwards for anyone running autonomous agents.

If anyone knows of another router that still offers automatic complexity-based tier selection without requiring manual headers per request, I'm all ears. Because right now, Manifest removing this feature leaves a real gap for agent-driven workloads.

[klausnitsche]

My experience completely matches yours, and I find the reasons given a bit lacking too.
On the other hand, it could be a conscious product decision for their commercial cloud product in order to not having to maintain complexity routing.
Speaking of alternatives, I found a few I'll shortly test.

• I looked at LiteLLM shortly but found it way too heavy for my use case.
• NadirClaw (https://github.com/NadirRouter/NadirClaw) looks like a possible candidate but it needs to be configured via text files (no quick config changes possible via UI).
• Routerly (https://github.com/Inebrio/Routerly) once they release v0.3.0.
• Adaptive LLM Gateway (https://github.com/renefichtmueller/adaptive-llm-gateway) looks cool but seems a bit stale, with a solo maintainer.

My criteria:

• Complexity routing without having to maintain keyword lists in different languages
• Web UI for easy onfig changes
• Allow a multitude of providers, including subscription providers.

[jonasbareiss]

I agree, been playing with LiteLLM a bit, its actually quite simple to set up dockerized, but turned out as a resource hog.
Also doesnt accept Anthropic or ChatGPT subscription via OAUTH, so i am currently using Manifest as intermediate proxy. a bit clunky, but works with both Heuristic scoring as well as LLM scorer.

[zunami]

btw – LiteLLM just shipped Auto Router v2 with a complexity router. SIMPLE/MEDIUM/COMPLEX/REASONING tiers, rule-based scoring, multilingual, session affinity.

Funny how they managed to make it work across languages without an embedding call, while the official reasoning for deprecating this feature was that "rule-based routing only works in English" 🤷‍♂️