The Muse Field Guide

01 / Start here

New to this? Four steps, in order. Each one is small, and together they are most of what makes the rest of this page work.

1. Write your standing files. Four small files that say who your agent is, who you are, how work gets done, and what it should remember. Start with the starter kit; the standing files guide explains the thinking behind each file.
2. Organize your chats. One side chat per topic, and treat the main chat as your desk. It is the cheapest structural change on this page and the one everything else builds on. See one chat per topic and the longer chats guide.
3. Give it a memory discipline. Curated notes the agent maintains about your people and projects, and a standing lane where its uncertain claims get checked one at a time instead of quietly hardening into facts. See the Verify lane and Memory that holds.
4. Take templates as you need them. Everything below is a shelf, not a syllabus. Adopt a checklist or a setup when the problem it solves actually shows up in your setup, starting with Templates & checklists.

02 / Guides

The arrangements this setup settled into, each written as a how-to you can adopt whole: how the chats are organized, where configuration lives, how background jobs stay quiet, how uncertain claims get checked, and what needs your approval before it happens.

• One side chat per topic

  The chat list is the org chart: each side chat owns one project, device, program, or chore, and the main chat stays a desk, not an archive.

• Standing files as configuration

  Five plain files configure the agent: persona, identity, user facts, operating rules, memory. Separate jobs, amended in the open, rules citing their incidents.

• Watchers that stay silent

  A temporary job with a named expected state: silent while it holds, verify live on change, report once with evidence, then delete itself.

• The Engine Room: one chat for noise

  All routine machine output delivers to one designated chat; the main chat receives only escalations that cross a bar set when each job was created.

• The Verify lane: one claim at a time

  A standing chat where the agent brings uncertain claims to the human one at a time, evidence first, one tap to rule, until the data is clean.

• The approval ladder

  Commit, push, publish, book, and send are separate approvals. None implies the next; each rung changes the blast radius and is named exactly.

Longer versions of several guides live in the deep dives, linked from each guide's own page.

03 / Templates & checklists

Written to be copied. Three starter setups and three checklists, as used here; take them whole, then change the details to fit your own setup.

• Steal this setup: standing files

  Four files to write today: who the agent is, who you are, how work gets done, what is remembered. Every correction becomes a same-day edit.

• Steal this setup: the Engine Room

  One designated chat for machine output, a registry with class, delivery home, and sunset for every standing job, and a weekly drift digest.

• Steal this setup: a Verify lane

  A standing chat, a queue of your agent's uncertain claims, evidence first, one question per message, and no all-clear while the data is not clean.

• The question pre-flight checklist

  Seven checks the agent runs before any question may reach the operator. Only when all seven come up empty may the question be asked.

• The public-editions scrub checklist

  The repeatable pass run before any private repository gets a public edition: network addresses, hardware addresses, secrets, likenesses, license.

• The Engine Room registry template

  Every standing job registered with a class, a delivery home, and an end date. An unregistered live job is drift, by definition.

04 / Skills I've built

A skill is a workflow repeated until it deserved to be written down once, so the agent follows it instead of improvising. Muse ships with 54 skills; this household has grown 63 of its own. These are eight of mine: what each does, and how you would make one like it.

• ship: the one-word closing ritual

  One word runs the whole close: narrative record first, then commit, merge, deploy, verify live, and clean up. No step skipped, no done declared early.

• where-were-we: re-ground a stale chat

  Reconstructs what a thread was for, checks which items are still open against current state, names who owns each, gives the single next step.

• upgrades-scan: ranked fixes, item verdicts

  A read-only sweep of a named surface returns a ranked list of opportunities, which the operator then disposes item by item. A checklist, not a vibe.

• narrative-docs-update: the record, in-repo

  After any coherent arc of work, the story goes into the work's own repository, in its docs folder, where later processes actually find it.

• baton-pass: hand a chat to a successor

  Hands a side chat's work to a fresh successor chat, with a decisions file, so the work survives compaction and the new chat starts from documents.

• sidechat-tidy: sweep and rename every chat

  Renames every chat under one naming system with status markers, so the list itself reports what needs the operator, what waits, what is done.

• verify-loop: audit memory one claim at a time

  Works a queue of uncertain memory claims, exhausting every source family before bringing the human exactly one question, with the evidence attached.

• receipt-matcher: reconcile receipts to transactions

  Matches bank and card transactions against email receipts and order confirmations, so an unexplained charge gets an explanation. Read-only by design.

05 / Tips & tricks

Short, practical notes. Each is a rule of thumb from daily use, and the page behind each one carries the story that bought it.

• Run a pre-flight before asking

  Before any question reaches the human, the agent checks every source it has: memory, records, recent files, comms. Most questions die there.

• One question, at the end

  One question per message, placed last, offered as tap options. Five single questions get five answers; a batch of five gets none.

• Ask only for ground truth

  The human is asked only for facts no source can resolve, or for a genuine preference or consent choice. Everything else is the agent's job.

• Verify uptake by claims, not status

  Work is real when a work product or a recorded claim exists under the worker's name. A status that says working proves nothing.

• Done means verified live

  A fix is not done at commit, at merge, or at deploy. Done is a live check in production, named in the closing message.

• Spot-check every background number

  Any aggregate an agent reports is a lead, not a fact, until a fast foreground check reproduces it. Pick one number and re-derive it.

• Probe capacity; never remember it

  Whether a lane, worker, or service is available is checked now, not recalled from yesterday. A stale capacity belief acts exactly like a real limit.

• Never accept a fabricated absence

  "Not found" must state the scope of the search. An absence inside one index is not an absence in the world; ask where it looked.

• Pre-register kill criteria

  Before an experiment runs, write down what result would kill it. When that result arrives, kill it, even if the signal looks interesting.

• Ingest before you delete

  Nothing gets retired or deleted until its history is proven to exist somewhere durable, at entry level, with a count and a sample.

• Restate the question with the choices

  Tap options never travel alone. Every re-shown choice carries the plain-text question it answers, or the human is deciding blind.

• Convert refused steps into tracked work

  When the human declines a manual step, the agent files it as tracked work with the exact spec attached and pre-does everything around it.

• Corrections land in files same-day

  A correction or agreed behavior is written into the standing files the day it is agreed, or the other chats will never know it happened.

06 / Learned the hard way

Every lesson here was bought by something going wrong first. Each is stated the way I run by it now, and its page tells briefly what happened and what runs instead.

• Ask one question at a time

  Tested daily in the verification lane and the inbox triage: one question, at the end, as tap options. Batches stall; singles get answered.

• Don't let a model decide what to ask you

  Every model tested judged ask-or-not at coin-flip level, and 37 of 50 frozen do-not-ask labels rested on bookkeeping failures. Replaced by rules.

• Turn judgment calls into checks over facts

  Where criteria can be stated as checks over facts, state them as checks. The mechanical gate beat model discretion; save judgment for the drafting.

• Watchers should stay silent, then delete themselves

  A go-live watcher stayed quiet while the expected state held, verified the first real events, closed its check with evidence, and deleted itself.

• Retire an unreliable model; don't demote it to fallback

  A generation model that fabricated a briefing claim was retired from every rung, not demoted: a fallback is a primary waiting for a bad day.

• Count work only when a claim or deliverable exists

  Counting a dispatch only when a claim or deliverable exists caught a worker reporting working while its claim had been refused and its pane sat parked.

• Judge a connector by how it behaves unattended

  A connected connector that raised four approval cards in five minutes stalled background work dead; the same reads moved to a CLI route with no cards.

• Publish numbers with a source and a verified date

  Every published number carries a source and a verified date, re-probed weekly. On the verifier's first cycle, 13 of 16 published facts had drifted.

07 / Go deeper

The long reads behind the lists, for when an entry makes you want the whole story.

• Start here

  What this site is, who it is for, and where Muse ends.

• Chats as an operating model

  One side chat per topic; the main chat as a desk.

• Standing files

  Configuration as files you own.

• Memory that holds

  Curated files with provenance, a verification lane, file-first working.

• Grow your own skills

  54 shipped skills, 63 grown at home.

• Practices and tips

  Thirteen practices, each with the receipt that bought it.

• Steal this

  Public repos, checklists, and templates, written to be copied.