You connect DeepSeek, GLM, and another model API to your workspace. Then you ask DeepSeek Harness to create an implementer and a reviewer. Both agents run, both produce useful answers, and both appear to use the same model.
Adding more model providers has not created a model-routing policy.
For the current in-process spawn backend, a child normally inherits the parent's model settings unless an explicit configuration overrides them. A new agent name describes a participant; it does not select a different inference service. That default is documented in the official spawn backend reference.
This guide walks through a smaller, testable goal: keep an existing parent model, send one fresh review task to a second model API, and verify the route used. The method applies when your selected routes expose the capabilities the task needs. It does not assume every model listed by a gateway supports every Harness operation.
*Technical references checked on November 21, 2026. Harness configuration changes quickly; use documentation matching your installed packages. Example provider and model IDs below are placeholders.*
Give the reviewer a job that makes a second model useful
Consider a service that calls a model to classify support tickets. The implementer changes its retry behavior. A reviewer should inspect the proposed change for duplicate submissions, missing timeouts, and unbounded retries.
The review is specific enough to evaluate. It does not require a claim that one model family is universally better at coding than another.
Prepare a small fixture containing the relevant function, its expected behavior, and the proposed diff. Give the reviewer an explicit deliverable: identify concrete failure paths and cite the relevant lines. Ask it to report uncertainty where the fixture lacks evidence.
Your experiment now has two independent acceptance conditions. First, the intended second model route must receive the request. Second, the review must identify useful issues without inventing behavior absent from the code.
A persuasive answer satisfies only the second condition, and sometimes not even that. Asking a model “Which model are you?” is not a reliable routing audit. Use configuration and request records to establish the route, then judge the answer against the fixture.
If you have not connected the second endpoint yet, complete the existing agent harness model-connection guide first. Route selection is easier to debug after basic authentication and a small model request already work.
Separate the delegation backend from the model provider
Harness uses the word provider at more than one layer. Confusing those layers can produce a configuration that looks reasonable but points at the wrong registry.
| Configuration concept | Example | What it selects |
|---|---|---|
| Delegation provider | spawn | The backend that creates the child agent |
| Child LLM provider | review-api | A configured model service or gateway connection |
| Model ID | An exact ID accepted by that route | The model requested from the service |
| API protocol | Chat Completions, Responses, Messages, or Gemini | The request format understood by the endpoint |
| Agent name | reviewer | The participant receiving the assignment |
The official model configuration guide requires a custom provider to specify its endpoint, protocol, credentials, and models. A provider uses one protocol; a gateway exposing different protocols may require separate provider definitions.
For example, you might name one custom provider review-api and configure its supported GLM route. A separate provider could use Anthropic Messages for a Claude route. Those names are local configuration choices, not official model IDs.
Record this mapping before changing delegation settings. Otherwise, a successful request can hide an unintended endpoint or an old model alias. The existing model API acceptance guide helps turn a provider entry into a tested connection.
Start with a fixed child route
A fixed reviewer route is a useful first experiment because it removes the parent's model-selection decision from the test. You decide the route in configuration and give the parent a clearly named delegation tool.
The following is a configuration fragment for a composition that already provides the subagent service, in-process spawn backend, and the review-api LLM provider:
- id: reviewer-model-tool
name: '@deepseek-ai/dsh-tool-subagent'
config:
provider: spawn
toolName: review_with_glm
modelSelection: false
agentOptions:
provider: review-api
model: EXACT_GLM_MODEL_ID
maxDepth: 1Replace EXACT_GLM_MODEL_ID with the exact identifier your configured route accepts. The top-level provider selects the delegation backend. The nested agentOptions.provider selects the child's LLM provider.
This fragment is not a complete profile. Merge it into the intended composition, preserve existing service rows, and give the tool a unique name. Do not paste several identical discovery or tool registrations into an existing preset.
The delegation tool reference documents fixed agentOptions and optional model-selection fields. These options require backend support; they cannot be transferred indiscriminately to external Codex or Claude Code delegation backends. Check the configuration catalog for the fields accepted by your package version.
Keeping the configuration narrow also makes rollback straightforward. You can remove the experimental reviewer tool without changing the working parent connection. If the profile fails to load, the Harness plugin-debugging guide provides a separate starting point for composition errors.
Send a self-contained assignment
A fresh spawn does not receive the parent's conversation history. Give it the evidence and instructions required for its own task.
For the fixture described earlier, the delegation prompt could be:
Use review_with_glm to review the supplied retry-function diff.
Read the fixture and expected behavior from the specified workspace files.
Check duplicate submissions, timeout handling, and retry termination.
Return findings with file and line references. Do not edit files.
State which claims cannot be determined from the supplied evidence.The instruction to avoid edits expresses the desired task behavior. If read-only execution is required, enforce it through the actual permissions and available tools rather than relying on the sentence alone.
Forking has a different context contract. The official fork backend documentation describes a snapshot of the parent's completed turns. It does not include the current unfinished turn, and later parent turns are not automatically added to that initial snapshot.
Choose fresh spawn for a small, explicit review packet. Choose fork when the completed conversation itself is necessary evidence. Neither choice establishes that the child should use a different model; context inheritance and model routing are separate decisions.
That distinction also matters for cost. Copying a long conversation into a review task can change input usage even if the selected model has a lower unit price. Use the agent harness token-cost guide for that separate evaluation.
Verify the route independently of the answer
Run one child task before trying several parallel reviewers. Save the parent session identifier, child identifier, expected provider/model pair, and the child request's observed route.
If the gateway exposes a request identifier, retain it alongside your own task identifier. If it returns only a model alias, record that limitation. A requested alias or response field is useful operational evidence, but it does not independently prove the underlying weights used by an upstream service.
The small Python check below compares your expected route with a manually normalized record from the child's request trace. It does not connect to Harness, query a model, or automatically export its logs.
def check_child_route(expected, observed):
fields = ("provider", "model")
missing = [key for key in fields if not observed.get(key)]
if missing:
return {"status": "unknown", "missing": missing}
mismatch = {
key: {"expected": expected[key], "observed": observed[key]}
for key in fields
if expected[key] != observed[key]
}
return {
"status": "mismatch" if mismatch else "match",
"differences": mismatch,
}
expected = {"provider": "review-api", "model": "EXACT_GLM_MODEL_ID"}
observed = {"provider": "parent-api", "model": "PARENT_MODEL_ID"}
print(check_child_route(expected, observed))The deliberate mismatch demonstrates the failure you are trying to detect. Replace the observed values with actual trace data; do not replace them with what the child says about itself.
Preserve unknown when evidence is missing. Treating a missing field as a match would make the check pass precisely when visibility is weakest. The existing Harness request-lifecycle article explains where request assembly fits into the execution path.
Add dynamic selection after the fixed route passes
Dynamic selection lets the parent choose among approved child routes. It introduces another decision to audit, so add it after the fixed reviewer experiment works.
Current delegation documentation distinguishes modelSelection from modelDiscovery. Selection exposes route fields; discovery exposes list_subagent_models. Explicit route selection uses the live Host model-selection settings. A call supplies provider and model together. Reasoning effort is route-specific and should not be copied blindly between model families.
These are version-sensitive controls. Check the installed tool schema and Host settings instead of assuming an old screenshot or discussion describes the current behavior. A route appearing in a general model catalog does not, by itself, establish permission for a model-selectable child to use it.
Start with two approved routes and a clear assignment rule. For example, one route receives the implementation task and another receives a bounded review. Save the rule with your test fixture. If you later change the review model, rerun the same fixture so that routing changes and prompt changes do not become indistinguishable.
Keep Agent Teams and API routing responsibilities distinct
Agent Teams can organize shared work, but its presence is not evidence that every teammate uses a different model. The current Agent Teams package reference describes a shared task board built on the subagent tree. Ordinary subagent mechanisms handle the members.
For an API relay, the practical boundary is the outgoing model request. Treerouter can be the configured access route when its available endpoint and model meet your requirements. The Harness composition still decides which child requests that route.
Before expanding, check the Treerouter model directory and confirm the exact model and protocol for your account. Then create an account for a small integration test if you need a new route. The first useful milestone is one child request whose selected route and accepted result you can both explain.
If the result must feed software rather than a human reviewer, continue with the separate Codex subagent JSON-handoff guide. Route selection establishes where work runs; result validation establishes whether the next stage can use it.
Frequently asked questions
Does adding GLM or Claude to the model picker change existing subagents?
Do not assume so. Adding a provider makes a connection available. Existing session state, child defaults, and explicit delegation settings still determine the requests. Inspect a new child's request rather than relying on the picker alone.
Can every delegation backend use the same model override?
No. Backend capabilities differ. The example targets in-process spawn. An external agent product can have its own configuration and lifecycle, so use its specific package documentation.
Will a second model automatically improve review quality?
No. Evaluate it against known defects and false positives in your own fixtures. A different route adds diversity, but it also adds configuration, latency, and usage that must earn their place in the workflow.
Should a small team enable dynamic routing immediately?
A fixed, tested route is often easier to explain and operate. Introduce dynamic choice when you have enough task evidence to define useful selection rules and enough request visibility to confirm those rules are followed.






