openclaw - ✅(Solved) Fix sessions_spawn has no warm-reuse path: every delegation pays cold-start tax [1 pull requests, 1 participants]

openclaw2026-04-10 14:18:47

ON THIS PAGE

Recommended Tools

×6

Utilities matched from this issue’s tags and category — try them while you read without losing context.

GitHub issue graph ai analysis

Paste a GitHub issue URL. We fetch that issue, discover linked issues from bodies/comments/timeline, collect linked pull requests, and produce a structured English report.

The report is written in English Markdown for sharing and archival.

GitHub issue URL

Helpful · Quick feedback

GitHub stats

openclaw/openclaw#64347•Fetched 2026-04-11 06:15:18

View on GitHub

Comments

Participants

Timeline

Reactions

Author

tylerco

Participants

tylerco

Timeline (top)

cross-referenced ×1

Root Cause

File: dist/pi-embedded-CNTNdlGw.js Line: 13901

const childSessionKey = `agent:${targetAgentId}:subagent:${crypto.randomUUID()}`;

crypto.randomUUID() is called unconditionally on every sessions_spawn. There is:

No check for an existing warm subagent session for the same target agent
No config flag to enable reuse
No session pool

Contrast with direct agent invocation via openclaw agent --agent gilfoyle --message ..., which uses the stable key agent:gilfoyle:main and benefits from warm cache reuse across calls.

Code Example

# Delegation 1 to Gilfoyle
# Session key generated: agent:gilfoyle:subagent:761a0cd4-3d94-4ff6-8653-12a0e6fa40cf
# cacheWrite: 15,377 tokens (~$0.058)
# Cost: $0.059

# Delegation 2 to Gilfoyle, 30 seconds later, identical workspace
# Session key generated: agent:gilfoyle:subagent:1bee5884-6595-4be3-aeaa-c6abe96230a5
# cacheWrite: 12,747 tokens (~$0.050)  ← cold again
# Cost: $0.050

---

const childSessionKey = `agent:${targetAgentId}:subagent:${crypto.randomUUID()}`;

---

subagents?: {
    allowAgents?: string[];
    maxConcurrent?: number;
    maxSpawnDepth?: number;
    maxChildrenPerAgent?: number;
    archiveAfterMinutes?: number;   // cleanup after N minutes
    model?: AgentModelConfig;
    thinking?: ...;
    runTimeoutSeconds?: number;
    announceTimeoutMs?: number;
    requireAgentId?: boolean;
};

---

subagents?: {
    ...existing fields...
    /** If set, sessions_spawn reuses an existing session with this key for the target agent instead of generating a new UUID. */
    reuseKey?: string;
};

---

const childSessionKey = config.subagents?.reuseKey
    ? `agent:${targetAgentId}:subagent:${config.subagents.reuseKey}`
    : `agent:${targetAgentId}:subagent:${crypto.randomUUID()}`;

RAW_BUFFERClick to expand / collapse

`sessions_spawn` has no warm-reuse path — every delegation pays cold-start tax

OpenClaw version: 2026.4.8 (9ece252) Severity: Cost / performance (per-delegation tax, ~$0.05 on Sonnet) Impact: Every call to sessions_spawn creates a brand-new ephemeral subagent session with a fresh UUID, forcing a full cold-start workspace bootstrap cache write on the subagent every single delegation — even when the same subagent was called seconds earlier with an identical task type.

Symptom

# Delegation 1 to Gilfoyle
# Session key generated: agent:gilfoyle:subagent:761a0cd4-3d94-4ff6-8653-12a0e6fa40cf
# cacheWrite: 15,377 tokens (~$0.058)
# Cost: $0.059

# Delegation 2 to Gilfoyle, 30 seconds later, identical workspace
# Session key generated: agent:gilfoyle:subagent:1bee5884-6595-4be3-aeaa-c6abe96230a5
# cacheWrite: 12,747 tokens (~$0.050)  ← cold again
# Cost: $0.050

Each delegation pays ~$0.05–0.06 of cold-start bootstrap tax on the subagent side, regardless of proximity in time.

Root cause

File: dist/pi-embedded-CNTNdlGw.js Line: 13901

const childSessionKey = `agent:${targetAgentId}:subagent:${crypto.randomUUID()}`;

crypto.randomUUID() is called unconditionally on every sessions_spawn. There is:

No check for an existing warm subagent session for the same target agent
No config flag to enable reuse
No session pool

Contrast with direct agent invocation via openclaw agent --agent gilfoyle --message ..., which uses the stable key agent:gilfoyle:main and benefits from warm cache reuse across calls.

Config schema (for reference)

File: dist/plugin-sdk/src/config/types.agent-defaults.d.ts

The current subagent config surface is limited to spawn policy, not session reuse:

subagents?: {
    allowAgents?: string[];
    maxConcurrent?: number;
    maxSpawnDepth?: number;
    maxChildrenPerAgent?: number;
    archiveAfterMinutes?: number;   // cleanup after N minutes
    model?: AgentModelConfig;
    thinking?: ...;
    runTimeoutSeconds?: number;
    announceTimeoutMs?: number;
    requireAgentId?: boolean;
};

No reuseExisting, no warmSessionKey, no pooling.

Impact examples

For a fleet that uses a Chief of Staff / CTO / technician orchestration pattern (parent → Gilfoyle → Dinesh), where each layer uses sessions_spawn:

Workflow	Delegations/call	Cold-start tax
User asks "review X" (lookup)	1 × Gilfoyle + 0 × Dinesh	$0.05
User asks "diagnose and fix Y" (multi-step)	1 × Gilfoyle + 2 × Dinesh recon	$0.15
Comparison-mode model selection (Gilfoyle → 3 executors)	4 subagents	$0.20

Nothing in these delegations requires session isolation — they're all routine delegations that could reuse a warm session pool per target agent.

Proposed fix

Option A (minimal change, opt-in): Add subagents.reuseKey?: string so callers can opt into a stable key:

subagents?: {
    ...existing fields...
    /** If set, sessions_spawn reuses an existing session with this key for the target agent instead of generating a new UUID. */
    reuseKey?: string;
};

Then pi-embedded-CNTNdlGw.js:13901 becomes:

const childSessionKey = config.subagents?.reuseKey
    ? `agent:${targetAgentId}:subagent:${config.subagents.reuseKey}`
    : `agent:${targetAgentId}:subagent:${crypto.randomUUID()}`;

Callers can set a per-agent reuse key (e.g. "warm-pool") and get cache reuse across delegations.

Option B (automatic pooling, bigger change): Detect that a subagent session for the target already exists in the sessions store, hasn't expired (per archiveAfterMinutes), and isn't currently running; reuse it. Safer semantics but requires locking to handle concurrent spawns.

Option C (treat subagent as main): Provide a sessions_spawn flag reuseMain: true that routes the task into the target agent's main session key (agent:<id>:main) instead of creating a subagent session at all. Caller accepts the shared-history tradeoff.

Estimated saving

On a fleet doing 20 delegations/hour, at $0.05 cold-start per delegation:

Current: $0.05 × 20 × 24 × 30 = ~$720/month of pure cold-start tax
After fix (any of the three options): ~$50/month (only the first delegation per hour pays)

For a light fleet doing 5 delegations/day, savings are ~$7.50/month. Small in absolute terms, but the compounding effect hurts scaling.

Relay turns also pay a separate cold cache rewrite on the parent side — see 01-relay-cache-invalidation.md. Together, the two issues make Reeves → Gilfoyle → paragraph summary cost ~$0.25–0.40 per call when the underlying reasoning is worth maybe $0.03–0.05.
Documentation-lookup tasks can bypass this entirely by having the parent agent read directly rather than delegate. But reasoning tasks (diagnosis, design, review) still pay the tax.

extent analysis

TL;DR

Implementing a session reuse mechanism, such as adding a reuseKey option to the subagents config, can help reduce the cold-start tax by reusing existing warm subagent sessions.

Guidance

Identify the subagents config and consider adding a reuseKey option to enable session reuse for target agents.
Evaluate the tradeoffs between the proposed fix options: minimal change with opt-in reuseKey, automatic pooling, or treating subagent as main.
Assess the potential cost savings by estimating the number of delegations per hour and the cold-start tax per delegation.
Consider the related issue of relay cache invalidation and its impact on overall costs.

Example

subagents?: {
    ...existing fields...
    /** If set, sessions_spawn reuses an existing session with this key for the target agent instead of generating a new UUID. */
    reuseKey?: string;
};

const childSessionKey = config.subagents?.reuseKey
    ? `agent:${targetAgentId}:subagent:${config.subagents.reuseKey}`
    : `agent:${targetAgentId}:subagent:${crypto.randomUUID()}`;

Notes

The proposed fix options have different implications for session management and cold-start tax reduction. The choice of option depends on the specific use case and requirements.

Recommendation

Apply workaround by adding a reuseKey option to the subagents config, as it is a minimal change that allows callers to opt into session reuse and reduce cold-start tax. This approach provides a balance between simplicity and effectiveness.

Vote matrix · Quick signals

Works

Did the solution work? Tap to confirm.

Easy Fix

Was it a quick fix?

Time Saver

Did it save you time?

Blocking

Was it severely blocking?

Common Issue

Are others likely hitting this too?

Flaky / Intermittent

Is it intermittent?

Verified / Reproducible

Can you reproduce it reliably?

#conversation history #tool integration #LLM response #prompt template #agent execution

Still need to ship something?

×6

Another batch ranked right after the header list — different links, same matching logic.

openclaw - ✅(Solved) Fix sessions_spawn has no warm-reuse path: every delegation pays cold-start tax [1 pull requests, 1 participants]

Recommended Tools

GitHub issue graph ai analysis

Root Cause

Fix Action

Fixed

PR fix notes

PR #64468: fix(agents): persist bootstrap marker after clean sessions_yield

Description (problem / solution / changelog)

Summary

Change Type (select all)

Scope (select all touched areas)

Linked Issue/PR

Root Cause (if applicable)

Regression Test Plan (if applicable)

Security Impact (required)

Human Verification (required)

Risks and Mitigations

Changed files