MARGENT

Overview

Agentic systems add sub-agents to improve answers. Each extra call costs computation and can leave the answer unchanged or turn a correct answer into a wrong one. Existing selective methods decide from query features, team structure or model confidence; none compares committing against delegating from the same reasoning state. The paper asks when additional intelligence is worth it.

MARGENT uses a trainable manager that writes the candidate it would submit now, then commits or delegates to one of three frozen sub-agents (Extractor, Reasoner, Verifier), revises the candidate from the returned signal and decides again. During collection it branches from the same manager-generated state into immediate commitment and every available delegation, scores the terminal branches with the gold answer, and reads off the marginal value of each call: rescue, no change or corruption. It then distills the shortest successful branch into supervised trajectories and fine-tunes only the manager.

91.7%

Gain@1, macro mean (Table 1)

Share of the measured oracle gain that the best single call recovers.

+17.1 pp

at 0.53 calls per example (Table 3)

Final answer vs the same manager's candidate on four collection-disjoint sets.

71.5%

MMLU-Pro: 1.07 selected calls match 3 forced calls (Table 5)

Development diagnostic. Same 71.5% accuracy as forcing all three sub-agents, at about a third of the calls.

81.1 vs 75.2

AQuA-RAT, selected vs force-all (Table 5)

Development diagnostic. Three forced calls lose 5.9 points to one selected call.

Overview of MARGENT in two halves. Left: from one shared manager-generated state the collector forces commitment and every available delegation, scores each branch, and distills a shortest successful trajectory into manager SFT data. Right: at inference the learned manager commits or delegates to an unused frozen sub-agent, updates its candidate from the returned structured signal, and decides again. — **Figure 1.** Overview of MARGENT: on the left, the collector evaluates commitment and every available delegation from one shared manager-generated state and distills a shortest successful trajectory into manager SFT data; on the right, the learned manager commits or delegates to an unused frozen sub-agent, updates its candidate from the structured signal, and decides again.

The delegate-or-commit interface

For a question x, the state at turn t is s_t = (x, h_t, ŷ_t, U_t): the question, the interaction history, the manager's current candidate solution and the set of sub-agents already used. The manager picks one action from Eq. 1; a commit submits ŷ_t and ends the trajectory, while a delegation appends the chosen sub-agent's output to the history, after which the manager revises its candidate and chooses again.

(1)u_t ∈ U(s_t) = {commit} ∪ {delegate(a) : a ∈ A \ U_t}

The three sub-agents in the experimental pool. All are frozen, greedy-decoded, and return structured decision signals rather than an answer.
Sub-agent	What it returns	What it receives
Extractor	Decision-relevant facts and their polarity	Question and context
Reasoner	A decomposition of the problem and the missing reasoning steps	Question and context
Verifier	An audit of the current candidate solution	Question, context, and the manager's current candidate

Invariants

Sub-agents are frozen. Only the manager is trained.
Sub-agents emit structured signals, never a choice label or final answer; the Verifier additionally receives the manager's current candidate as input.
Each sub-agent can be called at most once, so a trajectory has at most three delegations, and the manager owns both candidate revision and the final commitment.

MARGENT

(a) Interventional marginal-value measurement

(2)Δ(s_t, a) = C(s_t, delegate(a)) − C(s_t, commit) ∈ {−1, 0, +1}

C(s_t, commit) says whether committing the current candidate is correct, and C(s_t, delegate(a)) is the correctness of a branch that forces one delegation to a, lets the manager revise, and then commits without further delegation. +1 is a rescue, 0 means no change and −1 is a corruption; the value measures the whole call-revise-commit operation under the fixed revision protocol, not the intrinsic capability of the sub-agent.

A temperature-zero manager produces the root candidate without delegation; from that shared root the collector forces direct commitment and delegation to every sub-agent.
Search is breadth-first over ordered sequences of distinct sub-agents to a maximum depth D ≤ 3; for a wrong root it stops after the first depth that contains a success and keeps all equally short successes.
For a correct root only one-step delegations are evaluated, kept for corruption analysis; the gold answer scores terminal branches only and is never shown to the manager or the sub-agents.

(b) Marginal-value distillation

The three cases of the selection rule (Eq. 3 and 4).
Root candidate	Measured branches	Supervision target
Correct	One-step branches only, kept for corruption analysis	Commit immediately (ε)
Wrong, first success at depth d	Search stops at depth d; all successes at that depth are kept	One of the shortest successes, sampled with a fixed example seed: d calls, then commit
Wrong, no success to depth D	Every layer evaluated, none succeeds	No label (Σ* = ∅): the state teaches neither commit nor delegate

Commit trajectories are capped at ρ times the number of rescue trajectories, where ρ is a data-construction hyperparameter, and SFT updates the full manager, so candidate-to-final gains are end-to-end effects rather than routing-only effects.

Why not a per-call penalty

The rule imposes a lexicographic preference over measured successful trajectories: correctness first, then fewer delegations. A scalarized per-call penalty needs a task-dependent exchange rate between accuracy and calls; the trajectory target needs none, and ρ still controls how much direct-commit supervision is kept.

Experimental setup

Setup as reported in Section 4.1 and Appendix A of the paper.
Item	Value
Benchmarks	MedQA (medical), MMLU-Pro (broad knowledge), GPQA (scientific), AQuA-RAT (mathematical); all multiple-choice
Interventional collections	400 root states per task; GPQA 200
Development pools and locked evaluations	Development pools: MedQA 200, MMLU-Pro 200, AQuA-RAT 254, GPQA 100. Locked evaluations, one run each after fixing depth, ρ and checkpoint: MedQA 500, MMLU-Pro 500, AQuA-RAT 254. GPQA-Diamond-100 is disjoint from the GPQA collection but also serves as its development pool
Manager and sub-agents	Qwen3.5-9B manager, the only trained component; three frozen role-specific LoRA sub-agents on the same model family
Decoding	Greedy for interventional probes and sub-agent calls
Search depth	3 for MedQA and AQuA-RAT; 2 for the primary MMLU-Pro and GPQA collections
ρ sweep	{0, 0.5, 1, 2, 3}. ρ = 0 keeps only rescue states and those policies delegate on nearly every question; larger ρ keeps more states in which committing was already correct
Comparisons	(i) the policy's own candidate before any delegation; (ii) one forced Verifier call; (iii) all three sub-agents forced in the recorded scaffold order; (iv) the measured oracle, best evaluated sequence per example
Metrics	Exact-match multiple-choice accuracy; mean sub-agent calls per example; rescue/correction and corruption probabilities from paired outcomes

Results

5aHow much value is available after one delegation?

Grouped bars per task: commit accuracy, best one-call accuracy and best measured accuracy, with Gain@1 above each group. — **Figure 2.** Measured oracle accuracy by maximum delegation depth (Table 1): commit A₀, best single call A₁, best measured sequence A_D, with Gain@1 above each group. One call recovers most of the measured gain on every task.

Table 1. Measured oracle accuracy by maximum delegation depth. Each row comes from one shared collection, so depth comparisons do not mix runs. interventional collection, not a held-out evaluation
Task	n	Commit A₀	Best 1 call A₁	Best measured A_D	Gain@1
MedQA	400	76.00	91.75	92.25	96.9%
AQuA-RAT	400	54.25	85.75	87.25	95.5%
MMLU-Pro	400	53.25	71.75	73.50	91.4%
GPQA	200	43.00	65.00	69.50	83.0%
Macro mean	–	56.63	78.56	80.63	91.7%

Most of the recoverable value sits in the first well-chosen delegation: one call recovers over 90% of the measured gain on three tasks and 91.7% in the macro mean. A second call adds 0.5 to 4.5 points and the third adds zero on the two collections searched to depth three; GPQA, whose commit accuracy is closest to chance, gains the most from a second call (4.5 points).

5bThe value of a call depends on which sub-agent is called

Net marginal value of one forced call for each task and sub-agent, in percentage points around a zero line. — **Figure 3.** Net marginal value of one forced call, 100·Δ̄_a in points (Table 2). The Verifier dominates on every task; the Extractor is near zero or negative.

Table 2. Net marginal value of one forced call, 100·Δ̄_a, in percentage points. Positive cells have more rescue than corruption mass; negative cells have more corruption. interventional collection, one-step branches
Task	Extractor	Reasoner	Verifier
MedQA	+2.0	+6.8	+10.0
MMLU-Pro	−0.5	+2.3	+15.1
GPQA	+0.5	+4.1	+15.5
AQuA-RAT	−4.5	−4.3	+29.4

The same Reasoner is worth +6.8 points on MedQA and −4.3 on AQuA-RAT, and the Extractor is near zero or negative on all four tasks. The Verifier has the largest mean value everywhere but is not interchangeable: 12 MedQA and 9 MMLU-Pro questions are rescued by the Reasoner and not by the Verifier, and forcing the strongest role on every question still spends calls on already-correct candidates.

5cLearned delegation on collection-disjoint evaluations

Paired bars per task: candidate accuracy versus MARGENT accuracy on the collection-disjoint sets, and a second panel with calls per example. — **Figure 4.** Collection-disjoint evaluation (Table 3): the same manager's candidate versus MARGENT's final answer, and mean sub-agent calls per example.

Table 3. Evaluation on sets disjoint from the interventional collection. MedQA, MMLU-Pro and AQuA-RAT use checkpoints fixed before this single run. GPQA-Diamond-100 is collection-disjoint but also served as GPQA's development pool, so its row is a collection-disjoint evaluation rather than a locked one. "Candidate" is the answer the same manager would submit before its first delegation. locked evaluation (GPQA: collection-disjoint only)
Task	n	Candidate	MARGENT	Gain (pp)	Calls
MedQA	500	73.4	79.8	+6.4	0.460
AQuA-RAT	254	37.4	76.8	+39.4	0.780
MMLU-Pro	500	49.6	60.2	+10.6	0.352
GPQA	100	42.0	54.0	+12.0	0.510
Macro mean	–	50.6	67.7	+17.1	0.526

MARGENT's final answer is more accurate than the same trained manager's pre-delegation candidate on all four tasks, by 17.1 points in the macro mean at 0.53 calls per example. Checkpoints for MedQA, MMLU-Pro and AQuA-RAT were fixed before this single run; GPQA-Diamond-100 is collection-disjoint but also served as its development pool.

Caveat: end-to-end, not routing-only

SFT updates the full manager, so Table 3 is an end-to-end difference inside the same scaffold, not a routing-only effect or a gain over an independently prompted single model; on AQuA-RAT the tool-enabled scaffold's candidate is much weaker than a plain-answer prompt.

5dFewer calls at the same accuracy

Four panels, one per task, plotting accuracy against calls per example for the low-call and selected MARGENT points, one forced Verifier call and all three sub-agents forced. — **Figure 5.** Accuracy against mean sub-agent calls on the development pools (Tables 4 and 5). Blue: MARGENT from the low-call policy to the selected operating point; orange diamond: one forced Verifier call; violet square: all three sub-agents forced. About one selected call matches three forced calls. Development diagnostic.

Table 5. Development-set operating points with the same manager and sub-agent pool. Selected on the development pools, not additional held-out tests. Accuracies in percent. ΔAcc. is positive when MARGENT is more accurate than force-all. development diagnostic
Task	Selected MARGENT acc.	Calls	Force all acc.	Calls	ΔAcc. (selected − force all)
MedQA	85.0	1.000	86.5	3.0	−1.5
MMLU-Pro	71.5	1.065	71.5	3.0	0.0
GPQA	55.0	1.040	61.0	3.0	−6.0
AQuA-RAT	81.1	1.031	75.2	3.0	+5.9
Macro mean	73.2	1.034	73.6	3.0	−0.4

At about one selected call per example, MARGENT averages 73.2% at 1.03 calls against 73.6% at 3.0 calls for forcing all three sub-agents; MMLU-Pro matches at 71.5% (1.07 vs 3 calls), AQuA-RAT is 5.9 points better (81.1% vs 75.2%) and GPQA stays 6.0 points worse. On the same development pools, low-call MARGENT policies save 43.5% of calls against forcing one Verifier call on every example for about 1.6 accuracy points (Table 4, development diagnostic). That forced-Verifier baseline did not receive the candidate, so it is a strong operational baseline rather than a matched routing ablation.

5eDoes the policy call on the right states? development diagnostic

For analysis only, gold labels give the call gap (the probability of delegating when the candidate is wrong minus the probability when it is correct), which is positive on all four tasks at the selected development operating points: 0.381 on MedQA, 0.296 on MMLU-Pro, 0.067 on GPQA and 0.102 on AQuA-RAT. A matched-budget replay that fixes the role and call count and resamples examples 2,000 times puts MedQA's selected subset at 82.0%, above the random 95% interval [75.0, 81.0], with MMLU-Pro and GPQA inside their intervals, although this test does not isolate candidate use from query difficulty.

Arrows in the calls-versus-accuracy plane, one per comparison in Table 9, each from the lower to the higher commit-to-rescue ratio. — **Figure 6.** Changing only ρ (Table 9). Every arrow points to fewer calls; accuracy moves both ways. Development diagnostic.

Table 9. Controlled commit-to-rescue comparisons on development data. "All" keeps every available commit example. Each arrow changes only ρ within a fixed collection and training recipe. development diagnostic
Task / collection	ρ	Accuracy	Calls	Call gap
MedQA depth 2	0 → 3	85.0 → 82.0	1.000 → 0.405	.000 → .474
MedQA depth 1	1 → 2	80.5 → 82.5	.700 → .560	.299 → .381
MMLU-Pro depth 1	1 → 2	64.0 → 65.0	.475 → .390	.289 → .296
AQuA-RAT depth 3	0 → all	81.1 → 68.5	1.000 → .626	.000 → .195

Keeping more commit examples lowers the call rate in every pair and generally raises the call gap, but accuracy is not monotone: the aggressive AQuA-RAT comparison removes 37.4% of calls and loses 12.6 points, so ρ is a transparent control over policy behaviour, not a free efficiency gain.

5fDoes the candidate matter to a delegated call?

Verifier candidate ablation on AQuA-RAT. Same ρ = 0 checkpoint, which delegates on every example, and the same call budget; only the Verifier's `current_solution` input is blanked, with no retraining. development diagnostic
Metric	With candidate	Candidate blanked
Accuracy	81.1%	74.0%
Correction (fraction of all examples)	0.480	0.409
Corruption (fraction of all examples)	0.0240	0.0236

Blanking the candidate lowers accuracy from 81.1% to 74.0% and correction from 0.480 to 0.409 while corruption is essentially unchanged, so the candidate is a useful audit target for a delegated call; routing was fixed in this run, so the ablation does not show that the router uses the candidate when deciding whether to call.

Appendix diagnostics

Table 10 (Appendix D). The two recorded GRPO continuations: terminal binary correctness reward, no call penalty, both started from MARGENT's selective SFT checkpoints. Not a main comparison. Calls = mean sub-agent calls per example. appendix diagnostic
Run	Calls	Accuracy	Observed behaviour
MedQA, 8B manager	2.98	–	Approaches the three-call ceiling
MedQA, 9B manager	3.00	–	Three calls on every example; the solution is emitted late

Outcome-only GRPO continuations collapse to the three-call ceiling, 2.98 and 3.00 calls per example. Accuracy records for these two runs are missing from the exported record, so the appendix supports a claim about call behaviour only; for reference, one fixed MedQA SFT configuration with three extra seeds gives 80.5 ± 1.0 accuracy at 0.517 ± 0.043 calls.