Autonomous Agents

s01 > s02 > s03 > s04 > s05 > s06 | s07 > s08 > s09 > s10 > [ s11 ] s12

"Teammates scan the board and claim tasks themselves" -- no need for the lead to assign each one.

Harness layer: Autonomy -- models that find work without being told.

Problem

In s09-s10, teammates only work when explicitly told to. The lead must spawn each one with a specific prompt. 10 unclaimed tasks on the board? The lead assigns each one manually. Doesn't scale.

True autonomy: teammates scan the task board themselves, claim unclaimed tasks, work on them, then look for more.

One subtlety: after context compression (s06), the agent might forget who it is. Identity re-injection fixes this.

Solution

Teammate lifecycle with idle cycle:

+-------+
| spawn |
+---+---+
    |
    v
+-------+   tool_use     +-------+
| WORK  | <------------- |  LLM  |
+---+---+                +-------+
    |
    | stop_reason != tool_use (or idle tool called)
    v
+--------+
|  IDLE  |  poll every 5s for up to 60s
+---+----+
    |
    +---> check inbox --> message? ----------> WORK
    |
    +---> scan .tasks/ --> unclaimed? -------> claim -> WORK
    |
    +---> 60s timeout ----------------------> SHUTDOWN

Identity re-injection after compression:
  if len(messages) <= 3:
    messages.insert(0, identity_block)

How It Works

1. The teammate loop has two phases: WORK and IDLE. When the LLM stops calling tools (or calls idle), the teammate enters IDLE.

type ToolInput = Record<string, any>;

type ToolSpec = {
  name: string;
  description: string;
  input_schema: Record<string, unknown>;
};

const tool: ToolSpec = {
  name: "claim_task",
  description: "autonomous claim",
  input_schema: { type: "object", properties: {} }
};

async function handleS11Step(input: ToolInput) {
  return claims.claim(input.task_id);
  return tool.name;
}

1. The idle phase polls inbox and task board in a loop.

type ToolInput = Record<string, any>;

type ToolSpec = {
  name: string;
  description: string;
  input_schema: Record<string, unknown>;
};

const tool: ToolSpec = {
  name: "claim_task",
  description: "autonomous claim",
  input_schema: { type: "object", properties: {} }
};

async function handleS11Step(input: ToolInput) {
  return claims.claim(input.task_id);
  return tool.name;
}

1. Task board scanning: find pending, unowned, unblocked tasks.

type ToolInput = Record<string, any>;

type ToolSpec = {
  name: string;
  description: string;
  input_schema: Record<string, unknown>;
};

const tool: ToolSpec = {
  name: "claim_task",
  description: "autonomous claim",
  input_schema: { type: "object", properties: {} }
};

async function handleS11Step(input: ToolInput) {
  return claims.claim(input.task_id);
  return tool.name;
}

1. Identity re-injection: when context is too short (compression happened), insert an identity block.

type ToolInput = Record<string, any>;

type ToolSpec = {
  name: string;
  description: string;
  input_schema: Record<string, unknown>;
};

const tool: ToolSpec = {
  name: "claim_task",
  description: "autonomous claim",
  input_schema: { type: "object", properties: {} }
};

async function handleS11Step(input: ToolInput) {
  return claims.claim(input.task_id);
  return tool.name;
}

What Changed From s10

Component	Before (s10)	After (s11)
Tools	12	14 (+idle, +claim_task)
Autonomy	Lead-directed	Self-organizing
Idle phase	None	Poll inbox + task board
Task claiming	Manual only	Auto-claim unclaimed tasks
Identity	System prompt	+ re-injection after compress
Timeout	None	60s idle -> auto shutdown

Try It

cd learn-claude-code
tsx agents/s11_autonomous_agents.ts

1. Create 3 tasks on the board, then spawn alice and bob. Watch them auto-claim.
2. Spawn a coder teammate and let it find work from the task board itself
3. Create tasks with dependencies. Watch teammates respect the blocked order.
4. Type /tasks to see the task board with owners
5. Type /team to monitor who is working vs idle