Generic adapters vs model-native engineering

The key split

Model plumbing matrix

The Qwen Code five-layer config resolver

Qwen Code's ModelConfigResolver in packages/core/src/models/modelConfigResolver.ts is the most rigorous model configuration system in this TypeScript set. It defines five typed source layers with explicit precedence (highest to lowest):

Every resolved configuration field carries its source type, so you can always trace where a value came from. The OAuth flow for Qwen models is gated by a QWEN_OAUTH_ALLOWED_MODELS list — Qwen-specific auth is not exposed for non-Qwen models even if someone builds a config that tries to use it.

Kimi CLI's kosong package — provider-native message conversion

Kimi CLI is the only agent in this set that ships its own separate abstraction package (kosong) for multi-provider message conversion. Rather than a single generic converter, it has a dedicated file per provider family:

The Google adapter is worth noting specifically: most agents that "support Google" discover the id-field rejection in production and add a hotfix. Kimi CLI has API snapshot tests for this specific case, meaning it was caught and tested before shipping.

Prompt caching is where provider abstractions stop being generic

Prompt caching is a good stress test for every "multi-provider" claim on this page. The feature looks simple at the UI layer — cached tokens, lower bills, faster repeated turns — but the implementation differs sharply by provider. Anthropic wants explicit cache_control markers, Gemini uses cached-content resources, DashScope exposes vendor headers, and some OpenAI-style stacks mostly report cache hits after the fact.

Kimi CLI's compression prompt — structured XML output format

Kimi CLI's context compression is driven by a dedicated prompts/compact.md prompt that instructs the model to produce structured XML output — not free-form prose. The required output uses named tags with explicit retention rules:

Kimi also ships a prompts/init.md that instructs the model to explore the project codebase and produce an AGENTS.md file: project overview, build/test commands, code style, testing instructions, and security considerations — using the project's native language. This is a structured project-onboarding ritual that no other agent formalizes as a named prompt.

OpenHands — Nine Jinja2 prompt templates with XML sections

OpenHands has the most modular prompt system in the set: 9 Jinja2 .j2 templates in openhands/agenthub/codeact_agent/prompts/, assembled at runtime. The main template uses named XML sections: <ROLE>, <EFFICIENCY>, <FILE_SYSTEM_GUIDELINES>, <CODE_QUALITY>, <VERSION_CONTROL>, <PULL_REQUESTS>, <PROBLEM_SOLVING_WORKFLOW>, <SECURITY>, <EXTERNAL_SERVICES>, and <ENVIRONMENT_SETUP>. The security section includes {% include 'security_risk_assessment.j2' %} — a composable sub-template, not inline text.

The long-horizon variant (system_prompt_long_horizon.j2) extends the base to add <TASK_MANAGEMENT> and <TASK_TRACKING_PERSISTENCE> for the task_tracker tool. Additional templates: in_context_learning_example.j2, microagent_info.j2, additional_info.j2, system_prompt_interactive.j2, system_prompt_tech_philosophy.j2.

Codex — OpenAI-native with provider extensibility

Codex is built by OpenAI, and its default wire protocol is the Responses API (wire_api = "responses"). The legacy Chat Completions API (wire_api = "chat") is explicitly no longer supported — Codex produces a migration error at config parse time if you try to use it. However, Codex is not hard-coded to OpenAI's cloud:

The WireApi enum currently has a single variant (Responses), which means Codex is more OpenAI-centric than agents like Mux or Qwen Code that abstract across many API shapes. But the dedicated Ollama and LM Studio crates show OpenAI is investing in local model support beyond just cloud API access.

Hermes — Maximum provider breadth via OpenRouter

Hermes takes the opposite approach from Claude Code. Rather than being shaped around one model family, it is model-neutral by design: OpenRouter provides access to 200+ models through a single API endpoint. There is no native model assumption anywhere in the codebase.

This unlocks a unique feature: the Mixture of Agents (MoA) tool. Because Hermes has no model loyalty, it can run four different frontier models (Claude Opus, Gemini Pro, GPT-5, DeepSeek v3) in parallel via ThreadPoolExecutor, collect all four responses, and pass them to a fifth aggregator model that synthesizes the best answer. This is the only built-in MoA implementation in this set.

See the dedicated Hermes page for detailed coverage of the MoA tool and aggregation algorithm.

DeerFlow — LangGraph model factory

DeerFlow's model loading uses LangGraph's native model factory pattern. The vLLM provider specializes to preserve Qwen's reasoning fields, and the factory supports CLI-backed models (models where the actual inference is done by a subprocess CLI command rather than an API call). This extensibility is a result of the LangGraph architecture — any LangChain-compatible model can be plugged in via config.

The langgraph.json file defines graph entrypoints and can specify different models per node — meaning the planner, writer, and tools can theoretically use different models without any code changes, just configuration.

Auth and configuration maturity

My verdict on model handling

If you want the best provider-neutral design, look at Mux and Qwen Code. If you want the most honest model-native design, Claude Code is the clearest answer. If you want the most explicit multi-ecosystem adapter, Pochi wins. If you want the most extensible model factory, DeerFlow is the most interesting. If you want the most maximum model breadth (200+ models, no native preference), Hermes via OpenRouter wins outright. And if you want OpenAI-native with real local model support, Codex offers dedicated Ollama and LM Studio crates, not just config-level provider overrides.

The lesson is that "supports many models" is not one thing. Some repos are really doing transport compatibility. Some are doing routing. Some are doing full provider-specific product behavior. And some — like Hermes with MoA — are doing multi-model synthesis that requires genuine model-neutrality to work. The difference matters a lot when tool calling, reasoning settings, auth flows, or MCP behavior start to diverge.