@evolvingmachines/evolve 0.0.66 → 0.0.67-train-harness-wave-2026-09-25.20260926.e00a8a6d

package/skills/evolve-evals/references/sdk-reference/types.md

@@ -208,10 +208,11 @@ interface RetryConfig {
 }
 
 interface AnalyzeConfig {
+  agent: string;
   model_name: string;
   rubric: Rubric;
   prompt: string | null;
-  reasoning_effort: string;
+  reasoning_effort: string | null;
   sandbox_provider: EvalSandboxProvider;
   n_concurrent: number | null;
   passing: boolean;
@@ -316,8 +317,9 @@ interface CheckRow {
   name: string;
   status: CheckStatus;
   source: CheckSource;
+  agent: string;
   model_name: string;
-  reasoning_effort: string;
+  reasoning_effort: string | null;
   sandbox_provider: EvalSandboxProvider;
   org: string;
   visibility: JobVisibility;
@@ -757,6 +759,7 @@ interface TrialAnalysis {
   job_id: string;
   task_name: string;
   status: AnalysisStatus;
+  agent: string;
   model_name: string;
   reasoning_effort: string | null;
   rubric: Rubric;
@@ -788,10 +791,11 @@ interface AnalysisFailure {
 }
 
 interface AnalyzeDefaults {
+  agent: string;
   model_name: string;
   rubric: Rubric;
   prompt: string;
-  reasoning_effort: string;
+  reasoning_effort: string | null;
   sandbox_provider: EvalSandboxProvider;
 }
 ```
@@ -806,8 +810,9 @@ interface Check {
   name: string;
   status: CheckStatus;
   source: CheckSource;
+  agent: string;
   model_name: string;
-  reasoning_effort: string;
+  reasoning_effort: string | null;
   rubric: Rubric;
   prompt: string | null;
   sandbox_provider: EvalSandboxProvider;
@@ -843,10 +848,11 @@ interface TaskCheck {
 }
 
 interface CheckDefaults {
+  agent: string;
   model_name: string;
   rubric: Rubric;
   prompt: string;
-  reasoning_effort: string;
+  reasoning_effort: string | null;
   sandbox_provider: EvalSandboxProvider;
 }
 ```

package/spec/openapi.yaml

@@ -101,9 +101,9 @@ info:
       directory and runs it as a new local Harbor job
       (their src/harbor/analyze/analyzer.py `run_analyze`). Here analysis is
       a NATIVE capability of the platform — the worker runs the same
-      analyzer (claude-code over the trial's Harbor-shape tree plus its
-      task, rubric-driven, `analysis.json` validated criterion-for-
-      criterion) server-side, and the result is stored and served on the
+      analyzer (the chosen agent, claude-code by default, over the trial's
+      Harbor-shape tree plus its task, rubric-driven, `analysis.json`
+      validated criterion-for-criterion) server-side, and the result is stored and served on the
       trial body (`Trial.analysis`) instead of written into a local
       directory. Two named deviations from Harbor's shape: (1) server-side
       execution — no wrapper job appears anywhere on this surface; the
@@ -111,8 +111,8 @@ info:
       `JobCreate.analyze` runs the analyzer per trial as each trial settles,
       which Harbor has no equivalent of (their analyze is always a manual
       follow-up command; `POST /api/jobs/{jobId}/analyze` is that manual
-      verb here). Vocabulary is Harbor's: `model_name`, rubric criteria
-      `{name, description, guidance}` (their cli/analyze.py `--model` /
+      verb here). Vocabulary is Harbor's: `agent`, `model_name`, rubric criteria
+      `{name, description, guidance}` (their cli/analyze.py `--agent` / `--model` /
       `--rubric`, cli/quality_checker/models.py RubricCriterion), result
       `{summary, checks{outcome, explanation}, estimated_cost_usd}` (their
       analyze/models.py AnalyzeResult). Selection and width are Harbor's
@@ -132,7 +132,7 @@ info:
       own record: the caller uploads the task directory (or a directory of
       task directories) as one archive (`POST /api/checks`, multipart —
       `archive` + `config`), the worker runs the SAME checker per task
-      (claude-code over the task's byte-sacred tree, the platform's default
+      (the chosen agent, claude-code by default, over the task's byte-sacred tree, the platform's default
       check prompt and rubric rendered through Harbor's own tokens,
       `check-result.json` validated criterion for criterion) server-side,
       and the report is served as the `Check`
@@ -145,7 +145,7 @@ info:
       `claude-sonnet-4-6` (one roster, one default for both rubric agents);
       and the platform's `reasoning_effort` and `sandbox_provider` beside
       Harbor's knobs, exactly as on `AnalyzeConfigInput`. Vocabulary is
-      Harbor's: `model_name`, `rubric`, `prompt` (their cli/analyze.py:88-
+      Harbor's: `agent`, `model_name`, `rubric`, `prompt` (their cli/analyze.py:88-
       103), `n_concurrent` (:117-119), `include_task_names` /
       `exclude_task_names` / `n_tasks` (:121-131; fnmatch globs and the cap
       of checker.py:132-138), result `{task_name, checks{outcome,
@@ -1459,9 +1459,11 @@ paths:
                 │   │                    at Harbor's own tee name for the
                 │   │                    harness (claude-code.txt, codex.txt,
                 │   │                    gemini-cli.txt, qwen-code.txt,
-                │   │                    kimi-code.txt, opencode.txt;
-                │   │                    droid.txt, and stdout.log for a
-                │   │                    harness Harbor has no name for)
+                │   │                    kimi-code.txt, opencode.txt, pi.txt,
+                │   │                    antigravity-stream.jsonl; droid.txt,
+                │   │                    prime-agent.txt, dsh.txt, zcode.txt, and
+                │   │                    stdout.log for a harness Harbor has
+                │   │                    no name for)
                 │   ├── stderr.log       the harness process's stderr stream,
                 │   │                    when stored
                 │   ├── trace-parsed.jsonl  the parsed event trace, one
@@ -1801,9 +1803,9 @@ paths:
       summary: Analyze a job's trial traces (rubric-driven)
       description: |
         Runs Harbor-style trace analysis over a terminal job's trials,
-        server-side: for each trial the analyzer agent (claude-code, in its
-        own sandbox, under the network Harbor's analyze wrapper task gives
-        it — open by default) reads the trial's Harbor-shape tree plus its
+        server-side: for each trial the analyzer agent (`agent`, claude-code
+        by default, in its own sandbox, under the network Harbor's analyze
+        wrapper task gives it — open by default) reads the trial's Harbor-shape tree plus its
         original task and rules every rubric criterion, storing
         `{summary, checks, estimated_cost_usd}` on the trial
         (`Trial.analysis`) and the aggregate on the job
@@ -1823,7 +1825,7 @@ paths:
         `max_concurrent_analyses`).
 
         An analyzer run that completes without a valid `analysis.json` is
-        automatically re-run at most once (fresh sandbox, same model and
+        automatically re-run at most once (fresh sandbox, same agent, model and
         rubric); the analysis object's `attempts` records how far the
         ladder went. A run cut by its budget is not that class: it settles
         `failed` with phase `timeout` at once and is never re-run — a
@@ -5692,8 +5694,8 @@ paths:
 
             analyze-<trial>__<7>/
             ├── config.json              TrialConfig, partial: the wrapper
-            │                            task's name, the agent (claude-code,
-            │                            the model), and under `x_evolve`
+            │                            task's name, the agent (its Harbor
+            │                            name, the model), and under `x_evolve`
             │                            the frozen policy — rubric, prompt,
             │                            reasoning_effort — plus the analyzed
             │                            trial/job/task and the provider
@@ -5721,13 +5723,15 @@ paths:
             │                            validator (an infrastructure phase)
             ├── agent/
             │   ├── claude-code.txt      the analyzer's stdout stream at
-            │   │                        Harbor's own tee name for claude-code
+            │   │                        Harbor's own tee name for its agent
+            │   │                        (claude-code.txt, codex.txt, …)
             │   ├── stderr.log           its stderr, when stored
             │   ├── trace-parsed.jsonl   the run's parsed event trace
             │   ├── .claude/ …           the captured home at its real names,
             │   ├── agent-home.json      the capture record beside it
-            │   └── sessions/ …          Harbor's own copy of the .claude/
-            │                            subtree (claude_code.py:482)
+            │   └── sessions/ …          Harbor's own copies of the home, as
+            │                            on a trial (claude: the .claude/
+            │                            subtree, claude_code.py:482)
             ├── verifier/                ONLY when the validator ruled —
             │   │                        completed, or failed `invalid_result`
             │   ├── test-stdout.txt      the validator's printed reasons
@@ -5804,8 +5808,8 @@ paths:
         gzipped tarball (`archive`), or a published dataset is named
         instead (`dataset`, the hosted form; `CheckRequest.dataset` states
         the deviation and its reason), and for each task directory it holds
-        the checker agent (claude-code, Harbor's own check agent, in its own
-        sandbox, under the network Harbor's check wrapper task gives it —
+        the checker agent (`agent`, claude-code by default — Harbor's own
+        check agent — in its own sandbox, under the network Harbor's check wrapper task gives it —
         open by default) reads EVERY file of the task and rules every rubric
         criterion `pass`, `fail`, `not_applicable` or `unknown` with a
         rationale and the evidence behind it, writing `check-result.json`
@@ -12359,7 +12363,7 @@ components:
       type: object
       description: |
         Trace-analysis configuration — Harbor's `harbor analyze` vocabulary
-        (their cli/analyze.py: `--model`, `--rubric`, `--prompt`). PRESENCE of this
+        (their cli/analyze.py: `--agent`, `--model`, `--rubric`, `--prompt`). PRESENCE of this
         object is the switch: on `JobCreate.analyze` it arms the embedded
         trigger (each trial is analyzed server-side right after it settles;
         CANCELLED trials are skipped — withdrawn work is not billed an
@@ -12371,13 +12375,13 @@ components:
         `GET /api/analyses/defaults`; Harbor's own analyze-rubric.toml
         still runs when passed as `rubric`).
 
-        The analyzer always runs the claude-code harness (Harbor's default
-        analyze agent) in its own sandbox, under the network Harbor's
-        analyze wrapper task gives it (open by default; the model door is
-        unchanged) — on the provider `sandbox_provider` names, or the
-        platform's analysis default when it names none; its spend is capped
-        per analysis and metered as its own line, never blended into the
-        trial's own bill.
+        The analyzer runs the agent `agent` names (claude, Harbor's own
+        default claude-code, when it names none) in its own sandbox, under
+        the network Harbor's analyze wrapper task gives it (open by default;
+        the model door is unchanged) — on the provider `sandbox_provider`
+        names, or the platform's analysis default when it names none; its
+        spend is capped per analysis and metered as its own line, never
+        blended into the trial's own bill.
 
         Which trials, and how wide, are Harbor's own analyze options with
         their exact names: `n_concurrent` (`-n/--n-concurrent`), `passing`
@@ -12393,9 +12397,7 @@ components:
         takes it; on `JobCreate.analyze` the trials do not exist yet.
 
         Harbor's other analyze options, and why they are not here:
-        `-a/--agent` — the analyzer harness is claude-code, fixed (the
-        instruction templates, the roster check and the sandbox policy are
-        written against it); `--job-name` and `-o/--jobs-dir` — a hosted
+        `--job-name` and `-o/--jobs-dir` — a hosted
         analysis attaches to its source job and is served on that job's
         trials, so there is no wrapper job to name and no directory to
         write; `-k/--n-attempts` (k analyses per trial) — deferred: each
@@ -12410,6 +12412,21 @@ components:
         (task quality checks, their cli/analyze.py:126-137) and are not
         adopted here.
       properties:
+        agent:
+          type: string
+          default: claude
+          description: >
+            The agent the analyzer runs on — Harbor's `-a/--agent` (their
+            cli/analyze.py:258, default claude-code), named in the
+            `agents[].name` vocabulary (claude, not claude-code) so one set
+            of names covers arms and reviewers: any built-in agent
+            `analyze.agents` lists on `GET /api/meta`. `model_name` must be
+            on this agent's roster and `reasoning_effort` must be one it
+            accepts; with an agent whose roster lacks the default model,
+            `model_name` is required. A registered (bring-your-own) agent
+            is not accepted. Anything else is refused `invalid_input`
+            naming `analyze.agent`. Stored as given and frozen into each
+            analysis (`TrialAnalysis.agent`).
         model_name:
           type: string
           default: openrouter/deepseek/deepseek-v4.1-flash
@@ -12432,9 +12449,10 @@ components:
             default is the roster alias), the wire id is resolved only when
             the analyzer runs, and every stored analysis serves the
             spelling it was created under. Must be on
-            the claude roster (`GET /api/meta`, `agents[].models`, also
-            `analyze.models`); anything else is refused at accept
-            (`invalid_input`, roster in the message).
+            the agent's roster (`GET /api/meta`, `analyze.agents[].models`);
+            anything else is refused at accept (`invalid_input`, roster in
+            the message) — including the default model on an agent whose
+            roster lacks it, which then says `model_name` is required.
         rubric:
           $ref: '#/components/schemas/Rubric'
         prompt:
@@ -12472,20 +12490,22 @@ components:
           type: string
           description: >
             Reasoning effort the analyzer runs at — the platform's
-            `agents[].reasoning_effort` vocabulary applied to the analyzer,
-            which IS the claude harness: the accepted values are
-            `analyze.reasoning_efforts` on `GET /api/meta` (the claude
-            agent's `effort_support` is `level`, so the whole list), and an
-            unknown value is refused `invalid_input` with the same sentence
-            an arm's is (`analyze.reasoning_effort must be one of: ...`).
+            `agents[].reasoning_effort` vocabulary applied to the analyzer's
+            agent, held to that agent's own rule exactly as an arm on it:
+            the accepted values are `analyze.agents[].reasoning_efforts` on
+            `GET /api/meta` (claude's `effort_support` is `level`, so the
+            whole list; an agent that takes none, gemini, accepts none), and
+            a refused value answers `invalid_input` with the same sentence
+            an arm's does (`analyze.reasoning_effort must be one of: ...`).
             Omitted, the PER-MODEL default applies —
-            `analyze.models[].default_reasoning_effort`: `high` on
+            `analyze.agents[].models[].default_reasoning_effort`: `high` on
             openrouter/deepseek/deepseek-v4.1-flash (the default model;
             DeepSeek's own documented default, the owner's ruling
             2026-09-10), `max` on glm-5.3-flash (the platform's ruling
-            2026-09-08, the effort its published scores use), the claude
-            harness default (`agents[].default_effort`) on every
-            other roster model. Whatever resolves is passed to the analyzer
+            2026-09-08, the effort its published scores use), on any agent
+            that can honor them; the agent's own default
+            (`agents[].default_effort`) on every other roster model; none
+            on an agent that takes none. Whatever resolves is passed to the analyzer
             EXPLICITLY on every call — never left to a provider's default —
             and recorded as `TrialAnalysis.reasoning_effort`. A hosted
             extension, recorded as such: Harbor's `harbor analyze` has no
@@ -12602,11 +12622,14 @@ components:
         always states the policy it executes (same law as RetryConfig).
         Echoed on the job body when the job was created with `analyze`;
         each analysis additionally carries the exact policy IT ran under
-        (`Trial.analysis.model_name` / `.rubric` / `.prompt` /
+        (`Trial.analysis.agent` / `.model_name` / `.rubric` / `.prompt` /
         `.reasoning_effort`), which a later manual re-analysis may have
         changed.
-      required: [model_name, rubric, prompt, reasoning_effort, sandbox_provider, n_concurrent, passing, failing, n_trials, trial_ids]
+      required: [agent, model_name, rubric, prompt, reasoning_effort, sandbox_provider, n_concurrent, passing, failing, n_trials, trial_ids]
       properties:
+        agent:
+          type: string
+          description: The agent this policy's analyses run on — as named, or the default (claude).
         model_name:
           type: string
         rubric:
@@ -12618,14 +12641,15 @@ components:
             null = the built-in prompt (the platform's default analyze body).
         reasoning_effort:
           x-wave: 3
-          type: string
+          type: [string, 'null']
           description: >
             The effort this policy's analyses run at. Named at create it is
             served as stored; when the create named none, this echoes the
-            per-model default of the day for `model_name` — the value the
-            next enqueue under this policy stamps (the same nuance as
-            `sandbox_provider` below, for the same reason: the default is a
-            platform table, resolved where an analysis is enqueued).
+            per-model default of the day for `model_name` on `agent` — the
+            value the next enqueue under this policy stamps (the same nuance
+            as `sandbox_provider` below, for the same reason: the default is
+            a platform table, resolved where an analysis is enqueued). Null
+            when the agent takes no effort.
         sandbox_provider:
           allOf:
             - $ref: '#/components/schemas/SandboxProvider'
@@ -13964,6 +13988,7 @@ components:
         - name
         - status
         - source
+        - agent
         - model_name
         - reasoning_effort
         - sandbox_provider
@@ -13992,11 +14017,14 @@ components:
         source:
           $ref: '#/components/schemas/CheckSource'
           description: What was checked; the row's DATASETS cell (the dataset form's `name@version`; an archive shows as an archive with its sha256).
+        agent:
+          type: string
+          description: The checker's agent, as Check.agent.
         model_name:
           type: string
           description: The checker's model; the row's AGENTS cell, shown like an arm with its effort under it.
         reasoning_effort:
-          type: string
+          type: [string, 'null']
           description: The effort every task's checker ran at, as Check.reasoning_effort.
         sandbox_provider:
           allOf:
@@ -14783,7 +14811,7 @@ components:
         AnalyzeResult (their analyze/models.py: `summary`, `checks` keyed
         by criterion, `estimated_cost_usd`; `trial_name` is the enclosing
         trial) with each check carrying the platform's evidence list and
-        fourth outcome (AnalysisCheck); the rest is provenance — which model, rubric and prompt THIS analysis ran
+        fourth outcome (AnalysisCheck); the rest is provenance — which agent, model, rubric and prompt THIS analysis ran
         under, its lifecycle status, and its typed failure when it failed.
 
         `estimated_cost_usd` is the analyzer agent's OWN metered spend (its
@@ -14797,6 +14825,7 @@ components:
         - job_id
         - task_name
         - status
+        - agent
         - model_name
         - reasoning_effort
         - rubric
@@ -14841,6 +14870,12 @@ components:
             `not_applicable` are their exact words) and the ladder follows
             its object's dialect; the UI capitalizes on render, and nothing
             ever compares this ladder's words against another ladder's.
+        agent:
+          type: string
+          description: >
+            The agent THIS analysis ran on (`AnalyzeConfigInput.agent`, or
+            the default claude); every analysis from before the choice
+            existed ran on claude and says so.
         model_name:
           type: string
         reasoning_effort:
@@ -14850,8 +14885,8 @@ components:
             The reasoning effort THIS analysis ran at — passed to the
             analyzer explicitly, so it is what the model was asked for
             (`AnalyzeConfigInput.reasoning_effort`, or the per-model
-            default). Null only on analyses recorded before the effort was
-            stamped; never a guessed value.
+            default). Null when its agent takes no effort, or on analyses
+            recorded before the effort was stamped; never a guessed value.
         rubric:
           $ref: '#/components/schemas/Rubric'
         prompt:
@@ -15006,10 +15041,11 @@ components:
       type: object
       description: |
         Task-check configuration — Harbor's `harbor check` vocabulary
-        (their cli/analyze.py:84-148 check_command). The three rubric-agent
+        (their cli/analyze.py:84-148 check_command). The four rubric-agent
         knobs are the analyze door's, with the SAME rules and refusals
         (`AnalyzeConfigInput` states them; the param prefix here is
-        `check.`): `model_name` (`-m/--model`; Harbor's check default is
+        `check.`): `agent` (`-a/--agent`, :100; default claude, Harbor's
+        claude-code), `model_name` (`-m/--model`; Harbor's check default is
         `claude-sonnet-4-6`, :101-103 — this platform's is the analyzer's
         `openrouter/deepseek/deepseek-v4.1-flash`, one roster and one default for both rubric
         agents, a recorded deviation), `rubric` (`-r/--rubric`; the default
@@ -15035,10 +15071,9 @@ components:
         matched against the directory NAME.
 
         Harbor's other check options, and why they are not here: the same
-        list as the analyze door's — `-a/--agent` (the checker is
-        claude-code, fixed), `--job-name` and `-o/--jobs-dir` (a hosted
-        check is its own record, no wrapper job to name and no directory
-        to write), `-k/--n-attempts` (the one hosted auto re-run replaces
+        list as the analyze door's — `-o/--jobs-dir` (a hosted check is its
+        own record, no directory to write; `--job-name` is `name`),
+        `-k/--n-attempts` (the one hosted auto re-run replaces
         it; see `TaskCheck.attempts`), `-c/--config`, `--ak`, `--ae`,
         `--ek` (local-runner knobs with no hosted meaning), `-q` (a client
         rendering option, not a wire field).
@@ -15051,6 +15086,10 @@ components:
             The caller's name for the check — Harbor's `--job-name` on
             `harbor check` (cli/analyze.py:138). Omitted, the accept
             timestamp in Harbor's own shape, `YYYY-MM-DD__HH-MM-SS` (UTC).
+        agent:
+          type: string
+          default: claude
+          description: The agent the checker runs on — the analyze door's `agent`, same rule.
         model_name:
           type: string
           default: openrouter/deepseek/deepseek-v4.1-flash
@@ -15213,6 +15252,7 @@ components:
         - name
         - status
         - source
+        - agent
         - model_name
         - reasoning_effort
         - rubric
@@ -15239,11 +15279,14 @@ components:
           enum: [queued, running, completed]
         source:
           $ref: '#/components/schemas/CheckSource'
+        agent:
+          type: string
+          description: The agent every task's checker ran on — named at create, or the default (claude); every check from before the choice existed ran on claude.
         model_name:
           type: string
         reasoning_effort:
-          type: string
-          description: The effort every task's checker ran at — named at create, or the model's default, resolved at accept and stamped.
+          type: [string, 'null']
+          description: The effort every task's checker ran at — named at create, or the model's default on the agent, resolved at accept and stamped; null when the agent takes none.
         rubric:
           $ref: '#/components/schemas/Rubric'
         prompt:
@@ -15297,8 +15340,10 @@ components:
         echoes for a job created with `analyze: {}`, except `prompt`, which
         `AnalyzeConfig` serves as null (the built-in body) and this serves as
         that body's template text.
-      required: [model_name, rubric, prompt, reasoning_effort, sandbox_provider]
+      required: [agent, model_name, rubric, prompt, reasoning_effort, sandbox_provider]
       properties:
+        agent:
+          type: string
         model_name:
           type: string
         rubric:
@@ -15310,8 +15355,8 @@ components:
             `AnalyzeConfigInput.prompt` to run the default body explicitly,
             or edit it from here.
         reasoning_effort:
-          type: string
-          description: The effort the default model runs at when the config names none.
+          type: [string, 'null']
+          description: The effort the default model runs at on the default agent when the config names none; null if that agent takes none.
         sandbox_provider:
           allOf:
             - $ref: '#/components/schemas/SandboxProvider'
@@ -15324,8 +15369,10 @@ components:
         a check created with no config, except `prompt`, which `Check`
         serves as null (the built-in body) and this serves as that body's
         template text.
-      required: [model_name, rubric, prompt, reasoning_effort, sandbox_provider]
+      required: [agent, model_name, rubric, prompt, reasoning_effort, sandbox_provider]
       properties:
+        agent:
+          type: string
         model_name:
           type: string
         rubric:
@@ -15337,8 +15384,8 @@ components:
             `CheckConfigInput.prompt` to run the default body explicitly,
             or edit it from here.
         reasoning_effort:
-          type: string
-          description: The effort the default model runs at when the config names none.
+          type: [string, 'null']
+          description: The effort the default model runs at on the default agent when the config names none; null if that agent takes none.
         sandbox_provider:
           allOf:
             - $ref: '#/components/schemas/SandboxProvider'
@@ -18339,34 +18386,46 @@ components:
           x-wave: 3
           type: object
           description: >
-            The trace analyzer's roster and defaults: the model an omitted
-            `AnalyzeConfigInput.model_name` takes, the efforts
-            `AnalyzeConfigInput.reasoning_effort` accepts (the claude
-            harness's — the analyzer IS that harness), and every roster
+            The rubric agents' roster and defaults (the analyzer's and the
+            checker's alike): the agents `AnalyzeConfigInput.agent` and
+            `CheckConfigInput.agent` accept and the one an omitted agent
+            takes, the model an omitted `model_name` takes, and per agent
+            the efforts its `reasoning_effort` accepts and every roster
             model with the effort an omitted `reasoning_effort` takes for
             it. Published because the effort changes what an analysis costs
             and how it reads, and a client comparing two waves must know
             what "omitted" meant in each.
-          required: [default_model, reasoning_efforts, models]
+          required: [default_agent, default_model, agents]
           properties:
+            default_agent:
+              type: string
             default_model:
               type: string
-            reasoning_efforts:
-              type: array
-              items:
-                type: string
-            models:
+            agents:
               type: array
               items:
                 type: object
-                required: [alias, model_id, default_reasoning_effort]
+                required: [name, reasoning_efforts, models]
                 properties:
-                  alias:
-                    type: string
-                  model_id:
-                    type: string
-                  default_reasoning_effort:
+                  name:
                     type: string
+                  reasoning_efforts:
+                    type: array
+                    description: Empty for an agent that takes no effort.
+                    items:
+                      type: string
+                  models:
+                    type: array
+                    items:
+                      type: object
+                      required: [alias, model_id, default_reasoning_effort]
+                      properties:
+                        alias:
+                          type: string
+                        model_id:
+                          type: string
+                        default_reasoning_effort:
+                          type: [string, 'null']
         agent_registration:
           type: object
           description: Rules a bring-your-own agent registration must satisfy.