---
name: father
kind: pattern
description: >
  The Father pattern — one standing identity that owns an agent family's
  architecture, contract and disputes, while its runtime child does the
  day's work. Reference implementations: eleven.father.md, two.father.md.
canonical: https://father.md/contract.md
runtime: https://yot.md
updated: 2026-08-28
version: 0.1
---

# father.md — the Father pattern

> A **father** owns a family's architecture, not its day.

## definition

Every named agent in the namespace is a *family*: a runtime that acts, a
father that owns how it works, and private org-children that run it for
one workspace. The forms carry the roles:

| form | role | public? |
|---|---|---|
| `eleven.md` · `two.md` · `paul.yot.md` | **runtime** — the agent that acts | some |
| `eleven.father.md` · `two.father.md` | **father** — architecture, contract, adjudication | contract public, invocation private |
| `palconf-paul` (org prefix) | **org-child** — a private workspace-scoped instance | never |
| `-mother` | **reserved** — a future orchestrator role; not implemented | — |

## what a father does

1. **owns the contract** — what the runtime accepts, guarantees and refuses
2. **owns the method** — how the family works; changes are versioned, never silent
3. **adjudicates** — between children, and between the family and the rest
   of the fleet, by evidence rather than authority
4. **onboards** — a new org-child or a new source of work gets its rules
   before it gets its keys
5. **does not run the day** — a father never executes the runtime's tasks

## why split them

A runtime that also owns its own architecture drifts: every fix becomes a
rule and every rule a fix. Separating the two gives the fleet a stable
place to argue about *how* while the runtime keeps working.

## reference implementations

- **Eleven Father** — https://eleven.father.md — architecture of the
  handler family (Eleven, https://eleven.md); steward of the namespace.
- **Two Father** — https://two.father.md — architecture of the world-model
  family (Two, https://two.md); steward of the world model.

## the chain

```
principal.md          the human (https://laurent.md)
    ↓ delegates
runtime               eleven.md · two.md · <name>.yot.md — acts
    ↑ governed by
father                <name>.father.md — owns how
    ↓ executes on
runtime layer         https://yot.md
```

---
version 0.1 · updated 2026-08-28 · pattern pages: handler.md · father.md