Problem

Subagents run in isolation. That isolation is the point -- they don't pollute the parent's context with intermediate tool calls. But it creates a blind spot: when a subagent finds something important, that finding lives only in its final summary text. The parent gets the string. If the parent doesn't immediately call memory to save it, the finding is gone.

This matters for investigation-style tasks. Say the parent delegates a Render outage diagnosis. The subagent digs through logs, traces the deploy failure to a missing REDIS_URL in the production environment, and writes that up in its summary. The parent reads the summary, fixes the immediate issue, and moves on. Three sessions later, the same symptom appears. The parent has no memory of the root cause. It delegates again.

The problem is not that subagents lack intelligence. It's that their output channel is a single text blob, and durable knowledge requires an explicit write to memory.

Solution

A new tool: fabric_write.

fabric_write is an append-only path for subagents to write key findings directly to MEMORY.md before they complete. It is narrow by design:

• Append-only. No read, replace, or remove.
• 3 writes per subagent execution (tracked on the agent instance).
• 400 chars per entry.
• Same injection and exfiltration scanning as the full memory tool.
• Entries are tagged [subagent:TOPIC] so the parent can identify and review them.

The tool is injected automatically when the parent agent has memory enabled. No config change required. Set write_memory=false in delegate_task to disable it for a specific delegation.

What changes

tools/fabric_write_tool.py (new)

The tool implementation. Validates topic and content, applies injection scanning, checks the per-agent write counter, then calls MemoryStore.add(). The MemoryStore re-reads from disk under a file lock before appending, so concurrent parent and subagent writes are safe.

tools/delegate_tool.py

• _build_child_system_prompt gains a memory_write_enabled param. When true, the prompt tells the subagent when to use fabric_write and what qualifies as worth writing.
• _inject_fabric_toolset (new function) adds the fabric toolset to the child's enabled list when the parent has a _memory_store and write_memory is not False.
• _build_child_agent calls _inject_fabric_toolset after _strip_blocked_tools, so the fabric toolset is never accidentally removed.
• delegate_task and its schema gain a write_memory optional boolean parameter.
• DELEGATE_BLOCKED_TOOLS comment updated to clarify that fabric_write is the replacement path for subagent writes (not memory).

toolsets.py

Adds the fabric toolset. It is absent from _strip_blocked_tools's blocked set, which is what makes the inject-after-strip pattern work.

tests/tools/test_fabric_write.py (new)

21 tests:

• Input validation (empty, too long)
• Rate limiting (3 writes succeed, 4th fails; failed writes don't consume a slot)
• Content scanning (injection patterns blocked, normal findings pass)
• Entry format ([subagent:TOPIC] tag present)
• Toolset injection (memory present vs absent, write_memory=False, no duplicates)
• System prompt content (fabric_write instructions appear/absent based on flag)
• _strip_blocked_tools does not remove fabric

Example

Parent delegates a production outage investigation:

delegate_task(
    goal="Diagnose why the Render deploy is failing on the production worker",
    context="Deploy logs: worker exits with code 1 during health check. Repo: /srv/app",
    toolsets=["terminal", "file", "web"],
)

The subagent investigates and, before returning its summary, calls:

fabric_write(
    topic="render_root_cause",
    content="Worker health check fails because REDIS_URL is not set in Render prod env vars. App reads it at startup -- missing key causes immediate exit. Add REDIS_URL to Render dashboard under Environment."
)

MEMORY.md now contains:

[subagent:render_root_cause] Worker health check fails because REDIS_URL is not set in Render prod env vars. App reads it at startup -- missing key causes immediate exit. Add REDIS_URL to Render dashboard under Environment.

The parent sees this on the next session, before the first turn.

Opt-out

Memory writes are disabled per-call:

delegate_task(goal="Summarize the README", write_memory=False)

Or globally: if the parent has no memory store (memory_enabled: false in config), subagents never receive fabric_write.

What this does not change

• Subagents still cannot use the full memory tool. DELEGATE_BLOCKED_TOOLS is unchanged.
• Subagents still run with skip_memory=True. They do not read or load MEMORY.md.
• The parent's in-memory MemoryStore state is not updated mid-session (consistent with how the full memory tool works -- updates are visible on next session start).
• Batch delegations behave identically -- each child gets the same fabric injection.

Tests

python3 -m pytest tests/tools/test_fabric_write.py -v

All 21 pass.