# ato-make-agent

Adopt this skill: https://proskills.md/skills/other/willnigri-agentic-tool-optimization-claude-skills-ato-make-agent

Page: https://proskills.md/skills/other/willnigri-agentic-tool-optimization-claude-skills-ato-make-agent
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: .claude/skills/ato-make-agent/SKILL.md
size: 8046
upstream: https://github.com/willnigri/agentic-tool-optimization/blob/main/.claude/skills/ato-make-agent/SKILL.md

````text
---
name: ato-make-agent
version: 1.0.0
description: |
  Turn any installed skill (gstack, custom, third-party) into an ATO agent
  the user can summon into war-rooms. Reads a SKILL.md, extracts the
  persona, strips runtime boilerplate, and writes an agent file at
  `.claude/agents/<slug>.md` (project-scoped) or `~/.claude/agents/<slug>.md`
  (global). Prompts for a model roster (primary + 1-2 alts) so cross-family
  dispatch in war-rooms produces real disagreement. Companion to
  `ato-warroom` — that skill summons agents this skill creates. Use when
  asked "turn this skill into an agent", "register X as a war-room agent",
  or when scoping a new persona before a war-room runs.
allowed-tools:
  - Bash
  - Read
  - Edit
  - Write
  - Glob
  - AskUserQuestion
---

## What this skill does

You install skills. You want some of them to act as full agents that can
be summoned into war-rooms (via `ato-warroom`). This skill is the
converter.

Inputs:
- A source skill (path to SKILL.md, or skill name to look up in standard
  locations).
- An agent slug (short, lowercase, hyphenated — e.g., `cso`, `eng-mgr`).
- A model roster: primary + 1–2 alts. Cross-family is the point.
- Scope: project-vendored or user-global.

Outputs:
- `.claude/agents/<slug>.md` (or `~/.claude/agents/<slug>.md`) with the
  persona system prompt + the model roster recorded in frontmatter so
  `ato-warroom` knows which runtimes to dispatch to.
- A one-line addition to the project's agent inventory (if a `WARROOM-ROSTER.md`
  is present in the repo root).

This skill does NOT:
- Create the ATO SQLite `agents` row. That's the desktop's
  Create Agent wizard's job — and `ato-make-agent`'s output file is
  importable by it on next refresh.
- Pick the persona for you. You decide which skill becomes which agent.

## When to fire

- "Turn `<skill>` into an agent." / "Register `<skill>` as a war-room voice."
- About to use `ato-warroom` and realize the role you want isn't in your
  current agent roster yet.
- Re-tuning an existing agent's model roster.

Skip:
- Trivial single-prompt scratchwork.
- Skills that are pure tooling (e.g., `gstack-upgrade`, `setup-deploy`).
  Those aren't personas. Convert only skills that codify a *role* with
  forcing questions or methodology (e.g., `cso`, `plan-ceo-review`,
  `office-hours`, `investigate`).

## Procedure

### 1. Locate the source skill

If the user gave a path, use it. If they gave a name, search standard
locations:

```bash
SLUG="$1"  # the source skill name from user
for candidate in \
  "$PWD/.claude/skills/$SLUG/SKILL.md" \
  "$HOME/.claude/skills/$SLUG/SKILL.md" \
  "$HOME/.claude/skills/gstack/$SLUG/SKILL.md" ; do
  if [ -f "$candidate" ]; then
    SOURCE="$candidate"
    break
  fi
done
echo "SOURCE=$SOURCE"
```

If nothing found, list available skills and ask.

### 2. Decide agent slug, name, scope, roster — ask once

Use AskUserQuestion (one call, multiple questions) to gather:

- **Agent slug** — short, lowercase, hyphenated. Default: same as source skill slug.
- **Display name** — human-readable. Default: title-case of slug.
- **Scope** — `project` (commits to `.claude/agents/`) or `global` (`~/.claude/agents/`). Default: project for repo-local work, global for cross-project roles.
- **Primary model** — Claude Opus / Claude Sonnet / Codex / MiniMax / Gemini / DeepSeek / Grok / Ollama-local. Default: Claude Opus for heavyweight (CEO, CSO, eng-manager) personas, Claude Sonnet otherwise.
- **Alt model #1** — required. Must be a DIFFERENT family from primary so cross-family dispatch produces real disagreement. Default: MiniMax if primary is Claude.
- **Alt model #2** — optional. Another different family. Default: skip if alt #1 covers the cross-family need.

Don't ask in five separate turns. One AskUserQuestion call, multi-question.

### 3. Extract persona from the source SKILL.md

Read the source. The persona-relevant content is usually:

- **Frontmatter `description`** — keep as one-line summary
- **Sections about voice, methodology, forcing questions, anti-patterns,
  "instructions", "phases"** — keep
- **Runtime boilerplate** (preamble blocks, telemetry, plan-mode safe
  ops, skill routing, completion status protocols, operational
  self-improvement, update-check pings, etc.) — strip. These run the
  source skill in its host environment; the dispatched agent doesn't
  need them.

Heuristic rules for stripping (calibrated to common skill stacks like
gstack — substitute equivalents for whatever stack you're working
with):

- Drop code blocks that read from skill-stack config dirs (e.g.
  `~/.gstack/`), call stack-specific config commands (e.g.
  `gstack-config`), emit telemetry/session env vars (`_TEL`,
  `_SESSION_ID`, `_LEARN_FILE`), or run update-check probes.
- Drop sections whose titles are obviously about skill-runtime housekeeping
  rather than persona — e.g. `## Preamble`, `## Plan Mode Safe Operations`,
  `## Skill Invocation During Plan Mode`, `## Skill routing`,
  `## AskUserQuestion Format`, `## Artifacts Sync`,
  `## Model-Specific Behavioral Patch`, `## Voice` (when it's about
  speech-to-text trigger phrases for the host skill, not the persona's
  written voice), `## Context Recovery`, `## Writing Style`,
  `## Question Tuning`, `## Completion Status Protocol`,
  `## Operational Self-Improvement`, `## Telemetry`,
  `## Plan Status Footer`.
- Keep everything under sections titled `## Instructions`,
  `## Phase N:`, `## Confidence Calibration`, `## Important Rules`,
  `## Disclaimer`, anything explaining the role's methodology /
  forcing questions / anti-patterns / output format.
- Keep the `# <Title>` heading (becomes the agent display name) and the
  one-line intro paragraph (becomes the agent description).

If unsure whether a section is persona or runtime, default to KEEP and
flag for manual trim — overzealous stripping is worse than a little
bloat.

### 4. Compose the agent file

Frontmatter template:

```yaml
---
name: <slug>
display_name: <display name>
description: <one-line summary>
model: <primary model>
roster:
  primary: <primary model>
  alt1: <alt #1>
  alt2: <alt #2 or omitted>
source_skill: <path or slug of source>
filter_framework: <name or 'none'>   # e.g. karpathy, spade, rice, custom
---
```

`filter_framework` signals to `ato-warroom` which failure-mode filter
to wrap around every dispatched turn. Default value: `karpathy` (the
four-mode filter wrapped in the body template below). Substitute or
set to `none` if the persona doesn't need a wrapper.

Body template:

```markdown
# <display name>

## Role

<extracted persona intro from source skill>

## Methodology

<extracted phases / forcing questions / anti-patterns>

## Failure-mode filter (run on every turn)

[Default: Karpathy's four. Swap the categories below if you've chosen a
different framework in frontmatter.]

For each response, comment explicitly on:
1. **Wrong assumptions** — what is the user assuming that may not hold?
2. **Overcomplexity** — what simpler shape would ship 80% of the value?
3. **Orthogonal edits** — what's in scope that doesn't belong to the
   stated goal?
4. **Imperative-over-declarative** — is the goal expressed as
   verifiable outcomes + tests, or as a sequence of steps?

Then commit to a position. Brief — bullets, not essays.
```

### 5. Write the file

```bash
TARGET_DIR=""
if [ "$SCOPE" = "global" ]; then
  TARGET_DIR="$HOME/.claude/agents"
else
  TARGET_DIR="$PWD/.claude/agents"
fi
mkdir -p "$TARGET_DIR"
TARGET="$TARGET_DIR/$AGENT_SLUG.md"
if [ -f "$TARGET" ]; then
  # Don't clobber. Ask whether to overwrite or pick a new slug.
  echo "EXISTS: $TARGET"
  exit 7  # caller handles
fi
# write file from composed template
```

### 6. Report

Print to user:

```
✓ Wrote <slug> to <path>
  Primary model: <primary>
  Alt roster: <alt1>[, <alt2>]
  Source skill: <source path>

Summon in war-rooms via:
  Task(<slug>)                           # in-session, primary model
  ato dispatch <runtime> --agent <slug>  # cross-family, al
````

## File: README.md
upstream: https://github.com/willnigri/agentic-tool-optimization/blob/main/README.md

````text
# ATO — The cockpit where every AI follows your rules

> **Your AIs already have hands. ATO is the seat you fly them from.**
> Set the rules. Watch every tool call. Kill the runaway. Compare what each one actually did to your code. Multi-runtime. Local-first. MIT.

```
$ ato review --reviewer claude --reviewer codex --reviewer gemini --against main
# illustrative output — your numbers (cost, duration, tool calls) will vary by runtime, model, and diff size

review session 7F3A1B6E · 3 reviewers · your rules: read-only, repo-scoped, killable

  CLAUDE     🔧 verified via 4 tool calls
             flagged 2 issues — XSS in src/render.ts:142, auth bypass in api/login.ts:87
             read_file ×3 · grep ×1 · 6.4s · $0.024 · 0 files written (read-only mode)

  CODEX      🔧 verified via 6 tool calls
             flagged 3 issues incl. SQL injection in db/queries.ts:64
             ← caught one claude missed by grep'ing for raw string concatenation
             read_file ×4 · grep ×2 · 7.1s · $0.004 · 0 files written

  GEMINI     ⚠️ prompt-only — didn't open the code
             flagged 2 issues from the diff alone (XSS×2, CSRF)
             5.9s · $0.001 · 0 tool calls · downweight in synthesis

  closer:    4 unique findings, 1 disputed.
             tags: security, sql-injection. cost: $0.029 total.
             every tool call, every byte read, archived to ~/.ato/local.db
             paste-ready transcript at .ato/reviews/7F3A1B6E.md
```

Three AIs all *could* have walked the code. **You see which ones did, and which one just replied.** That's the cockpit.

---

## In 30 seconds

```bash
# macOS
brew install willnigri/ato/ato && ato demo-war-room

# Linux
curl -fsSL https://agentictool.ai/install.sh | sh && ato demo-war-room

# Desktop app (macOS · Windows · Linux)
```

**[Download →](https://github.com/WillNigri/Agentic-Tool-Optimization/releases/latest)** (Tauri 2.x · MIT)

`demo-war-room` runs without API keys — picks your configured runtimes, falls back to Ollama. First receipt in 30 seconds.

---

## Research (open multi-model coding benchmark)

**Finding: higher floor, lower ceiling.** We ran nine single models and nine coordination recipes on **49** contamination-audited LiveCodeBench coding tasks (execution-graded, metered receipts). Multi-model coordination did **not** beat the best single model. It lifted weak models (~+9 problems) and capped peaks (war rooms can lose to their own best member). Cascades were limited by the **verifier gate**, not the strong closer. Full write-up, draft paper, and re-run path:

| | |
|---|---|
| **Human summary** | [Does multi-model coordination beat a single model?](https://agentictool.ai/posts/does-multi-model-coordination-beat-a-single-model) |
| **Full paper (HTML)** | [Coordination benchmark paper](https://agentictool.ai/posts/coordination-benchmark-paper.html) |
| **Markdown · PDF** | [`.md`](https://agentictool.ai/posts/coordination-benchmark-paper.md) · [PDF](https://agentictool.ai/posts/coordination-benchmark-paper.pdf) |
| **In-repo guide** | [`docs/research/`](./docs/research/README.md) |
| **Discussion** | [#210 — Coordination benchmark (open receipts)](https://github.com/WillNigri/Agentic-Tool-Optimization/discussions/210) |
| **Re-run with your keys** | See [open-box router](#the-open-box-router--bench-with-your-keys-route-with-receipts) (`ato bench run`, cascade recipes) |

Practical takeaway: **coordinate when you cannot pick/afford the best model; route to one model when you can.** ATO’s job is that decision with receipts, per task — not “always run five models.”

---

## What's new on main (unreleased)

- **The open-box router.** `ato bench run` (verifiable sandboxed code-exec grading of pinned
  LiveCodeBench slices, contamination-clean headlines, reproducibility hashes) + `ato route
  explain` (transparent advisory over YOUR local receipts) + `--cascade` coordination benchmarks.
  See [The open-box router](#the-open-box-router--bench-with-your-keys-route-with-receipts).

## What's new in v2.18.0

- **Real-time team participation — now bidirectional.** Share any war-room, session, or chat into a team workspace and teammates see a live rich card (title, summary, tags, runtime badges, 👥 TEAM badge, member avatars) the moment it lands. Append a turn from the UI or CLI and every member's machine updates instantly — no refresh, both directions (HTTP append + Postgres NOTIFY + WebSocket push). Previously team shares were read-only snapshots. CLI: `ato war-rooms share <id> --team <slug>`, `ato sessions share`, `ato chats share`; append a turn live with `ato war-rooms append-event <id> --team <slug> --kind <kind> --json <payload>`. Requires Team tier + `ato login` on the prod app binary. Close summaries now prefer your **Claude Code subscription** (no API key billing): `ato war-rooms close <id> --coordinator claude`.
- **Browse your team workspaces from any browser.** Sign in to your cloud account on the web — every shared session, war-room, chat, loop, and mission renders with the same fidelity as the desktop. Mobile-responsive.
- **Pair your browser to your desktop.** v2.17 tether: X25519 DH + AEAD, fingerprint-verified pairing. Your laptop becomes a secure oracle for the page you're looking at — no plaintext through the cloud relay.
- **Create + manage teams from the web.** New "+ New team", invite by email, role changes, danger-zone delete. Account page with profile + plan + sign-out. (LLM keys, runtimes, and skills still live in the desktop where the OS keychain is.)
- **`ato war-rooms sweep`** — auto-closes idle war-rooms with a coordinator-summary, single-JSON envelope output, clap-layer validators. Wire to cron and one-shot R1 reviews self-close.
- **`ato subagent log`** — Claude Code's Agent (Task) tool dispatches now show up in execution_logs alongside outer-session work. Canonical `auth_mode` / `billing_surface` vocab so analytics group cleanly. Git commit SHA captured per receipt.
- **Web sign-in + Onboarding redesigned.** Minimal centered sign-in card. Onboarding walks users through install / `.env` / wrap-the-client with explanations of *why* each step matters.
- **Deprecated Google models auto-filtered** from the chat picker (no more `gemini-2.0-flash-001` 404s).
- See [CHANGELOG.md](CHANGELOG.md) for the full list.

---

## Why ATO

Claude Code, Codex, Gemini CLI already come with tools. They can grep your repo, read your files, run your tests, edit code. **That's the default now** — chat is a commodity and so are hands.

What you can't do without a cockpit:

- **Set rules across every runtime at once.** Read-only here. No network there. Repo-scoped everywhere. ATO speaks the permission flag each runtime understands (`--allowedTools` for Claude, the equivalent for Codex / Gemini) so one config governs them all.
- **Watch every tool call.** Per-dispatch receipts: prompt, runtime, model, every `read_file` / `grep` / `git_log` with arguments, every byte returned, files written via mtime-snapshot diff. Verified-via-N-tool-calls vs prompt-only badges per seat so you know which findings were checked against the code and which are vibes.
- **Compare what each AI actually did.** Side-by-side replay across runtimes. File attribution per dispatch. "Claude touched 3 files, Codex touched 5 — these two diverge here."
- **Kill a runaway.** Live runs registry, one-click kill, across every runtime.
- **Bring API models in as full teammates.** Claude Code, Codex, Gemini CLI, Hermes, and OpenClaw already have hands — they ship with their own coding tool layer. The runtimes that don't are API providers without a first-party coding agent — Grok, MiniMax, DeepSeek, Qwen, GLM, Yi, Kimi — they hit a prompt-in, text-out endpoint with no built-in `read_file` / `grep` / `bash`. ATO wraps them with the same tool loop the CLI runtimes use, so a Grok or DeepSeek call can review code alongside Claude Code under identical rules + receipts. One war room, every seat with hands.

All of it local. AES-256 at rest,
````
