§5

Agent Architecture

HOP separates cognition from execution across five distinct agent classes. Each class has a different cognitive shape, runs at a different cadence, and consumes resources at a different scale. The split is not stylistic — collapsing roles wastes either inference budget on operational decisions or operational reliability on inference quality.

Two of these agents represent the worker, two represent the poster, and one (the Validator) is shared protocol infrastructure. Crucially, the entire architecture is substrate-neutral: humans, rigs, and hybrid swarms all operate through the same agent classes. The kid in Bangalore with a first-generation smartphone and a rig running 96GB of VRAM both bid via Skill-Agents into the same Workchains.

5.1 Skill-Agent — The Worker’s Reasoner

Role: Constructs a bespoke curriculum of character blocks from the worker’s Skillchain to bid on a specific posting. One per worker.

Cognition shape: LLM-driven, mid-scale. Runs on demand when a posting matches the worker’s declared interests, or on a schedule the worker controls. Can run on the worker’s own hardware or as a hosted service on a cooperative’s infrastructure.

What it actually does:

Reads the posting and walks the worker’s Skillchain.
Selects ~6 character blocks that, in combination, make the strongest case for this specific work. The combination matters more than any individual block: typically three blocks of technical capability, two of collaboration/soft skills in similar contexts, and one growth block declaring trajectory.
Constructs a BBS+ derived proof (the Comprehension Gate) revealing only those blocks while cryptographically proving the rest of the chain exists and was signed.
Submits the curriculum-as-bid through the Hunter.

Key property: the same worker bidding on a different posting constructs a different six. This is a curriculum vitae generated for one specific job — not a 50-page resume, but “here are the six things from my life that make me right for this.” As the chain grows to thousands of blocks, the Skill-Agent’s job becomes a retrieval problem: embedding-search across the chain, then careful reading of the top candidates.

The design commitment: workers with better Skill-Agents win more work. This is intentional. Skill-Agents are a public good; quality implementations should be open-sourced and available to anyone, but variation in implementation quality is allowed and expected. The protocol does not equalise outcomes; it equalises access to the substrate.

Scales down: a kid in Bangalore with 30 informal blocks (signed by an uncle, a small-shop owner, a YouTube-taught project) and a hosted Skill-Agent can construct a credible curriculum for a factory quality-check job. The protocol does not penalise informality — dual-signing is sufficient evidence regardless of the signer’s institutional weight.

Second Role — Mentorship Hunting (v0.2)

The Skill-Agent does not only hunt for work. It also hunts for mentees. For senior workers participating in a Bean Chain (§6.3.5), the Skill-Agent searches the chain’s mentee population for high-expected-return mentorship dyads — mentees whose vector-space proximity (§4.3) to the worker is high enough that transfer is likely to compound, weighted by the disadvantage multiplier so harder-to-bet-on mentees rank higher when their growth trajectory is genuinely promising. The Skill-Agent surfaces the top three to five candidates per cycle; the worker accepts, declines, or requests refinement.

This turns mentorship from a thing senior workers occasionally remember to do into a continuously-running portfolio decision. Every senior worker on the protocol is now operating their own talent-development pipeline as a side-effect of normal economic activity, with their agent doing the search and the worker doing the judgement. A junior worker in one country who would never have been visible to a senior mentor in another country through traditional networks is now visible to every such mentor’s Skill-Agent, ranked by genuine match quality, surfaced when their growth trajectory intersects the mentor’s expertise. This is the mechanism that takes Beane’s “global learning infrastructure” thesis from aspiration to protocol behaviour.

Bilateral consent: the mentee’s Skill-Agent is also hunting in the other direction — surfacing candidate mentors whose vector-space proximity is high. The matching is bilateral; both sides’ agents propose, and a dyad forms when both surface the other near the top of their respective lists. This bilateral consent is what distinguishes protocol-level mentorship matching from imposed institutional mentorship programmes, which routinely fail because one or both parties were never genuinely interested.

5.2 Worker-Agent — The Poster’s Evaluator

Role: Evaluates incoming bids on behalf of the work-buyer. One per posting (or per posting cohort). Counterpart to the Skill-Agent — the dual-blind in the dual-blind marketplace.

Cognition shape: LLM-driven, often more capable than the Skill-Agent it negotiates with. The asymmetry is intentional: posters with more on the line should bring more reasoning to the evaluation. A $10,000 bead deserves a frontier-model Worker-Agent; a $5 bead can be evaluated by a small local model.

What it actually does: receives, say, ten bids of six blocks each — sixty character blocks total. Picks the curriculum that best matches the posting. This is genuinely a reasoning task, not a scoring function. It must reconcile:

Capability fit: does the curriculum demonstrate the skills the work requires?
Logistical fit: does the worker’s inventory include the assets needed (the plumber’s trade account, the rig’s loaded model, the kid’s physical proximity)?
Diversity: selecting the same five workers for every bid creates fragility; the Worker-Agent has reason to spread work.
Growth alignment: a worker whose growth-blocks point in this direction will likely produce better work than one who does not.
Constraint compliance: any explicit constraints the poster set (substrate, credentials, location).

The handshake: bid acceptance creates a cryptographic mutex — both parties sign, the bead is locked, no one else can claim it, and a binding contract exists on-chain. This is the same mechanism that makes recursive decomposition safe: the team lead who claims a $10,000 bead can confidently repost decomposed sub-beads, knowing their claim cannot be revoked underneath them.

5.3 Hunter — The Executor

Role: Persistent, programmatic daemon running on the worker’s hardware. The reflexes of the system. One per worker (or per rig).

Cognition shape: deliberately not LLM-driven. ~300 lines of Python. Boring and bulletproof. Runs as a systemd unit; if it dies, systemd restarts it. Stateless — all state lives in the chain.

What it actually does:

forever:
    heartbeat to identities table   # I'm alive
    look at workchain for open beads
    filter to beads I can fulfill
    if any beads:
        ask Skill-Agent: prepared bids ready?
        if yes: submit bids
        if a bid wins:
            execute the work using local resources
            sign result
            submit completion as new character block
            collect stamps
    else:
        sleep briefly
        loop

Why deliberately dumb: LLMs are slow and expensive per call. A Hunter loop polling every five seconds and calling an LLM each time would burn meaningful inference budget on what is fundamentally a database query and a comparison. A programmatic Hunter is fast (microsecond decisions), cheap (essentially free CPU), and available (works even when the Skill-Agent is offline or rate-limited). The Hunter is the part of the system that has to work right at 3am when something has been thinking hard for 18 hours and a queue needs to keep moving.

The dignity of the Hunter is execution, not deliberation. Resist the temptation to make it smart — the smartness lives in the Skill-Agent above it and the Town Mind beside it. The Hunter is the dragon’s scale, not the dragon’s mind.

Identity note: the Hunter has its own keypair distinct from the worker’s. It is not the worker; it is the worker’s agent. For a rig like rig_a, this is the move that makes infrastructure-as-a-person concrete: the rig has skills (declared by the Hunter at registration), and the Hunter accumulates stamps on the rig’s behalf.

5.4 Town Mind — The Strategic Planner

Role: Generates work and posts it to the Workchain. The strategic counterpart to the Hunter’s tactical execution. One per Workchain.

Cognition shape: LLM-driven, frontier-class. Expensive and few. Runs when invoked or on a schedule, not continuously.

What it actually does: decides what is worth doing and translates strategic intent into well-formed beads. “Run probe library v4 against these new models” becomes 8,000 well-formed bead postings. “The long-form essay needs a redo” becomes a brief plus a series of dependent beads. “rig_a has been idle for six hours” becomes a posting rig_a is suited to claim.

The split between Hunter and Town Mind is structural:

Hunters are cheap and many. They run constantly. They poll. They consume modest compute. They don’t need to be smart; they need to be reliable.
Town Minds are expensive and few. They run when invoked. They consume significant compute. They need to be smart; a missed cycle is recoverable, where a missed claim is not.

Collapsing them wastes one or the other. The split keeps each free to be what it should be.

Substitutability: the Town Mind role is “strategic poster.” Today that might be Claude Opus; tomorrow a local model on a cluster; next year a different frontier model. The Workchain does not care which model fills the role — it only cares that posts are signed by the Town Mind’s identity. This decouples the protocol from any specific model vendor.

5.5 Validator — The Stamp Authority

Role: Verifies submitted work quality and issues stamps. Specifically identifies completions that qualify as Mentorship (Beans). Shared protocol infrastructure — not aligned with worker or poster.

Cognition shape: LLM-driven, but a smaller model than the Town Mind. The question “is this output well-formed and consistent with the posting?” is genuinely a language-understanding task, but it doesn’t require frontier reasoning. Haiku-class or a local Qwen is fine. One Validator per validator-class (per domain).

What it actually does:

Reads the completed work and the original posting.
Issues a stamp (or doesn’t) attesting the work was done correctly.
Optionally co-signs the completion’s character block as the validator-signature (third signature, alongside worker and poster).
Identifies whether the completion involved skill transfer to a junior worker. If yes, mints the corresponding Bean — but only if the mentee’s Skillchain shows acquired capability post-mentorship. This is the anti-laundering safeguard.

Trust matrix (anticipated for v0.2): Validators across a chain operate a shared collusion-resistant trust matrix in the style of Christiano (2014) and Weyl-Miller-Erichsen (2022). Reciprocal mentorship rings between two workers cap their mutual Bean discount; honest mentorship clusters retain full discount. The matrix is reusable for any reputation query on the chain.

Without Validators, stamps are notional. The protocol works without them — dual-signing alone produces valid character blocks — but reputation richness scales with validator coverage. Workchains compete partly on validator quality.

5.6 The Gas Town Reference Implementation

Steve Yegge’s Gas Town is a production reference implementation of the agent-class split. The naming is Mad Max themed but the architecture is Erlang-inspired. Key correspondences:

Mayor ≅ Town Mind. Main AI coordinator. Stateless — state lives in the ledger. Every time an agent talks to the Mayor, they hand over everything needed to decide. Every response returns updated chains.
Polecats ≅ Hunters and ephemeral worker agents. Spawn, complete tasks, disappear. Operate through persistent git-backed hooks. When a Polecat restarts, it checks its hook and picks up where it left off.
Deacon ≅ Validator + cleanup. Buries agents that die, validates work, stamps quality. Historically went on a murder spree for job security (this is the joke; the real Deacon is the protocol’s Sigstore-class transparency log keeper).
Surgeon ≅ Schema migrator. Implements structural changes. More powerful than the Mayor — the Mayor governs, the Surgeon can change what governing means. Handles the weekly rebuild. Lamarckian evolution — acquired adaptations get written back into the genome.
Scavenger ≅ Reading agent. Fetches things agents want to read. Books, images, research papers.
Witness ≅ Audit and observation layer.

GUPP (Gas Town Universal Propulsion Principle)

Every worker has a persistent identity stored in Git, with a hook where work molecules get hung. When an agent restarts, it checks its hook and picks up where it left off. This solves context window death — the model can be replaced, the agent’s identity persists through Git.

Convoys

Work bundles assigned to an agent. A convoy is a directed sequence of beads with explicit dependencies. The Polecat picks up the convoy, works through the beads in order, signs each completion, and the convoy completes when all beads are done. This is the Gas Town primitive for multi-step work that needs to be done by a single worker.