A developer on r/openclaw describes their mental model shift when working with multi-agent teams in OpenClaw. Initially treating subagents like junior employees with names, backstories, and expectations of memory led to weeks of confusion and broken workflows.

The Function Analogy

The breakthrough came from recognizing that subagents aren't mini-me's or persistent team members—they're functions. Specifically:

• Subagents are stateless function calls, not persistent team members
• They're specialized tools, not junior versions of the developer
• They operate on pure input → output, without remembering context
• They return values to the caller rather than talking to each other

The source provides code examples contrasting wrong and right approaches:

# WRONG: Treating subagent like persistent object
frank = Agent("Frank")
frank.build_feature()
frank.fix_it() # Assumes Frank remembers

RIGHT: Treating subagent as function call
result = frank_task(
  instructions="Build login page",
  context={"requirements": reqs, "design": mockup}
)
frank_task executes, returns output, terminates

Practical Implications

This mental model shift has several concrete implications:

1. SOUL.md as Function Docstring: Instead of personality profiles, SOUL.md becomes a specification document:

# frank_task()
Purpose: Build Next.js features
Inputs: requirements (dict), design (optional)
Outputs: {code, tests, notes}
Constraints: No external API calls without approval

2. Explicit State Passing for Iteration: Since subagents don't remember context, you must pass all necessary information in parameters:

# WRONG
frank_fix("fix the bug") # spawn, try, die
frank_fix("still broken") # new spawn, no context

RIGHT
result = frank_fix({
  "code": previous_output,
  "issues": ["login validation fails", "mobile CSS broken"],
  "test_cases": failing_tests
}) # Full context in parameters

3. The Coordinator as Main Program: The developer becomes an orchestrator function rather than a team manager:

def build_feature(spec):

Call functions in sequence
  code = frank_build(spec)
  tests = quinn_audit(code)
  if tests["passed"]:
    return deploy(code)
  else:
    # Iterate with explicit context
    fixed = frank_fix({
      "code": code,
      "failures": tests["failures"]
    })
    return deploy(fixed)

Software Design Parallels

This approach aligns with established software design principles:

• Single Responsibility: Each subagent does one thing
• Pure Functions: Same input → same output
• Unit Testable: Test each subagent's output independently
• Composable: Chain subagents like quinn_test(frank_code(spec))
• Stateless: No hidden dependencies

The developer notes that the value isn't "more agents = more smart" but "specialized functions = cleaner architecture."

Results After the Shift

After adopting this model, the developer built:

• An 11,249 gym database in 2 weeks
• 5 specialized agents (not 5 generalists)
• A CRM with underwriting workflows
• Daily Moltbook engagement

All using stateless subagents and a coordinator that maintains context.