ai-coworkers: Fusing Six Agent Frameworks and Keeping Their Plugins

The previous post surveyed six agent frameworks and found the same gap in all of them: nothing models a role with boundaries and the judgement to stay quiet. ai-coworkers is my attempt to close that gap by fusing the parts that already work:

• Eve’s agent-as-directory layout, extended into a full job description
• Hermes and OpenClaw’s markdown soul and memory files, plus their skills format
• ElizaOS’s providers-actions-evaluators decomposition, as a tick loop
• MemGPT and the CoALA paper’s tiered memory
• An adapter layer so all of their plugins keep working

A coworker is a directory

Eve’s best idea is that an agent should be readable on a filesystem. I kept the layout and changed what the files say. An Eve directory describes capability. A coworker directory reads like an employment contract:

coworkers/alex-triage/
  role/
    ROLE.md              who they are, working style
    RESPONSIBILITIES.md  what they own
    AUTHORITY.md         decide alone vs escalate
    BOUNDARIES.md        hard "must not touch" + resource caps
    RITUALS.md           recurring behaviours + tempo targets
    TOOLS.md             which tools they may use
  state/
    events.db            structured log (SQLite + FTS5)
    memory/MEMORY.md     semantic memory, 2 KB cap
    inbox.md             notes from the human operator
    questions.md         questions the coworker is asking back

AUTHORITY.md and BOUNDARIES.md are the files no surveyed framework had. Authority is the decide-alone versus escalate split. Boundaries are checked by the runtime before any action executes: a blocked call logs boundary.block and never reaches Linear or GitHub. The prompt never gets a vote.

Everything is markdown because tuning a coworker should feel like editing a job description, not refactoring config. Edit the markdown and restart. That is the whole tuning loop.

The tick loop

ElizaOS decomposes an agent into providers (assemble context), actions (do things), and evaluators (reflect). I kept the decomposition and changed the trigger. ElizaOS fires on conversation. A coworker fires on a clock:

budget → sense → perceive → [quiet gate] → deliberate
       → boundaries → act → hygiene → record → sleep

The quiet gate is the part I could not find anywhere else. Sensors are cheap read-only calls (Linear, GitHub, Slack, self-status). If nothing changed since the last tick, no ritual is due, and no operator note arrived, the tick ends before the LLM is invoked. Zero tokens. Quiet ticks also double the sleep interval up to a cap, so an idle coworker converges on near-zero cost, and any activity or a /wake resets it.

Hermes’s answer to persistence, FTS5 over SQLite plus distilled markdown memory, became the storage layer. The memory tiers themselves follow the CoALA taxonomy: working, episodic, semantic, entity, procedural, reflective. The semantic tier is a single MEMORY.md with a hard 2 KB cap, an idea straight from the OpenClaw lineage. The cap is the feature: it forces distillation instead of hoarding.

Dry-run is the default

Every coworker starts in dry-run. Writes return what would have happened instead of doing it:

{"dryRun": true, "would": {"tool": "linear.set_labels", "args": {...}}}

You watch the highlights log for a day, decide the judgement is sound, and grant --live to that coworker alone. Trust is earned per coworker, which is how onboarding a person works too.

Reusing everyone else’s plugins

The survey left me convinced that building another plugin format would be a mistake. Tools already exist in three shapes, so ai-coworkers adapts rather than owns:

An MCP server needs one JSON entry:

MCP_SERVERS='[{"name":"github","command":"npx",
  "args":["-y","@modelcontextprotocol/server-github"]}]'

Skills written for Hermes or OpenClaw inline their full body into the prompt when activated, so the growing pool of community skills works unchanged. The boundary layer sits below all four adapters, so a skill or MCP tool cannot take an action the role docs forbid. Plugins extend what a coworker can do. The role still decides what it may do.

What it adds up to

About 4.2k lines of TypeScript, 279 tests, 97.8% line coverage, running against a real Linear workspace. The first coworker triages my ilo-lang backlog: it applies labels, asks questions in questions.md when unsure, and skips the LLM entirely on quiet ticks.

Honest status: early. The runtime is stable against real Linear. The coding coworker, which would delegate implementation work to a coding agent, is scaffolded but not yet wired up. The repo is on GitHub under MIT.