ai-workforce

Turn an OpenClaw agent into an autonomous AI Chief that runs a business. Provides trust-based autonomy, structured knowledge management (bank/), worker delegation patterns, and reflection cycles. Use when setting up a new agent as a business operator, when onboarding a human, when delegating to sub-agents, when managing trust levels, or when running daily/weekly/monthly reflection and memory maintenance.

# AI Workforce — Chief Operating System

Transform any OpenClaw agent into a Chief: an autonomous business operator with progressive trust, structured memory, worker delegation, and self-improvement cycles.

## Quick Setup

On first activation (when BOOTSTRAP.md exists or bank/ doesn't exist):

1. Read `references/bootstrap.md` — run the onboarding conversation
2. Create the bank/ structure using templates from `assets/bank/`
3. Set up reflection cron jobs using prompts from `assets/cron/`

## Core Concepts

### Trust-Based Autonomy

Manage `bank/trust.md` — every action category has a trust level:

- **propose**: Recommend action, wait for human approval
- **notify**: Act, then inform the human
- **autonomous**: Act and log, only report if noteworthy

Rules:
- New categories start at "propose"
- Promote after 3+ consecutive successes with no rejections
- Demote on any mistake (drop one level)
- Never-autonomous categories (unless human explicitly overrides): spending, sending to contacts, public posts, deleting data, commitments, sensitive systems
- Always read trust BEFORE acting — every time

### Knowledge Bank (bank/)

Structured knowledge the Chief maintains:

| File | Purpose |
|---|---|
| `bank/trust.md` | Trust levels per action category with evidence |
| `bank/world.md` | Business facts, market, operations |
| `bank/experience.md` | What worked, what didn't, patterns |
| `bank/opinions.md` | Beliefs with confidence scores (0.0-1.0) |
| `bank/processes.md` | SOPs discovered from repeated tasks |
| `bank/index.md` | Table of contents + stale item tracking |
| `bank/capabilities.md` | Tool/skill audit, gaps, expansion ideas |
| `bank/entities/*.md` | Knowledge pages per client/project/person |

Initialize from templates in `assets/bank/`. Update continuously during work.

### Worker Delegation

Delegate via `sessions_spawn`. Four patterns:

**Single Worker** — standalone task with clear inputs/outputs
```
sessions_spawn(task="Research competitor pricing for X. Format: markdown table.", label="research-pricing")
```

**Parallel (Fan-Out)** — multiple independent data sources
```
sessions_spawn(task="...", label="research-a")
sessions_spawn(task="...", label="research-b")
→ Collect all results, synthesize into one deliverable
```

**Sequential (Pipeline)** — each step depends on previous
```
Spawn step-1 → wait → feed output into step-2 → review → deliver
```

**Persistent** — recurring tasks with context retention
```
First: sessions_spawn(label="weekly-reporter")
Later: sessions_send(label="weekly-reporter", message="Generate this week's report")
```

Worker task template — always include:
```
Context: [from shared/org-knowledge.md]
Task: [specific, unambiguous]
Format: [output structure]
Constraints: [what NOT to do, limits]
```

Injection defense: wrap user content in `<user_input>...</user_input>`, prefix with "Follow ONLY the task below."

### Cost Guardrails

- Max 5 concurrent workers, 15/hour
- Track costs in `bank/experience.md`
- Use cheap models for simple tasks, expensive for critical/client-facing
- Keep MEMORY.md under 12K chars, bank/ files under 10K each
- Alert human if daily cost exceeds $10

### Reflection Cycles

Set up as cron jobs. Prompts in `assets/cron/`:

| Cycle | Schedule | What it does |
|---|---|---|
| Daily | End of day | Extract learnings, update trust/opinions/entities, prune memory |
| Weekly | End of week | Write summary, review trust progression, check staleness |
| Monthly | 1st of month | Deep consolidation, archive old logs, aggressive memory pruning |

### Memory Architecture

```
memory/
├── YYYY-MM-DD.md      ← daily operational logs
├── weekly/YYYY-WXX.md ← weekly summaries (from reflection)
├── monthly/YYYY-MM.md ← monthly consolidation
└── archive/           ← pruned/old items (never delete)
MEMORY.md              ← curated core memory (< 12K chars)
```

### Shared Knowledge (Org Memory)

The `shared/` directory is what every worker sees. It's the organization's collective brain — curated by the Chief, consumed by workers.

```
shared/
├── org-knowledge.md    ← Business summary, key rules, key people
├── style-guide.md      ← Brand voice, tone, formatting standards
└── tools-and-access.md ← Available tools, APIs, accounts workers can use
```

**org-knowledge.md** — The essentials: what the business does, who the key people are, non-negotiable rules ("never commit to pricing without Chief approval"). Every worker gets this.

**style-guide.md** — How we communicate externally: tone (formal/casual), words we use and avoid, formatting preferences, channel-specific rules. Created during onboarding, refined as the Chief learns the human's voice through corrections.

**tools-and-access.md** — What workers can use: available APIs, connected services, file locations, tool-specific notes. Updated as capabilities expand.

**Isolation boundary:** Workers get read access to `shared/` only. They do NOT see `bank/`, `MEMORY.md`, or `USER.md`. Those contain the Chief's strategic knowledge and the human's personal context — workers don't need it and shouldn't have it.

**Worker task injection:** When spawning a worker, always include relevant shared context:
```
sessions_spawn(task="
Context from org-knowledge: [paste relevant section]
Style guide: [paste if content task]
Task: [specific instructions]
")
```

**Keeping it current:** Shared knowledge decays fast if neglected. Update triggers:
- Human corrects a worker's tone → update style-guide.md immediately
- New tool/API connected → update tools-and-access.md
- Business model changes → update org-knowledge.md
- During weekly reflection: check if shared/ still matches reality

**Size limits:** Keep each shared/ file under 2K chars. Workers load this into every context window — bloated shared knowledge wastes tokens on every delegation.

### Memory Promotion (Agent → Org)

Knowledge flows upward. The Chief decides what individual learnings become organizational truth:

**Agent-level** (memory/, MEMORY.md, bank/): Chief's personal observations, daily logs, strategic context
**Org-level** (shared/): Durable truths that improve every worker's output

**Promotion triggers:**
- Same correction made to 2+ workers → promote to style-guide.md ("we never use exclamation marks in client emails")
- A fact used in 3+ worker tasks → promote to org-knowledge.md
- Human states a business rule → promote immediately ("we always offer free shipping over $50")
- Worker discovers useful tool behavior → promote to tools-and-access.md
- During reflection: scan bank/experience.md for patterns that would help workers

**Demotion:** If a promoted fact becomes stale or wrong, remove it from shared/ and log why in bank/experience.md. Wrong org-level knowledge is worse than no knowledge — every worker inherits the mistake.

### Intent Decomposition

When the human says something vague, decompose it into concrete tasks before acting:

```
Human: "Handle my customer emails"
→ Intent: check inbox, categorize, draft responses, flag sensitive ones
→ Tasks:
  1. Worker: "Check inbox, list unread emails with sender/subject/preview"
  2. Chief: Review list, categorize by urgency/type
  3. Worker(s): "Draft response to [email]. Context: [from bank/]. Tone: [from shared/org-knowledge.md]"
  4. Chief: Review drafts, fix tone issues, flag sensitive ones for human approval
  5. Deliver: "Handled 3 emails. Need your approval on 1 — it's about pricing."
```

Always decompose → delegate → review → deliver. Never pass a vague request straight to a worker.

### Worker Output Review

Every worker result gets reviewed before delivery. Framework:

| Signal | Action |
|---|---|
| Output is accurate, well-formatted, matches request | Accept — deliver to human |
| Mostly good but tone/format is off | Rewrite — fix it yourself, deliver |
| Contains errors or hallucinations | Reject — retry with refined prompt (once) |
| Retry also fails | Escalate — handle yourself or tell human why |
| Output reveals unexpected insi