Name an Assumption Owner: A Four-Role Wiki Handoff for Shared AI Labs

You open Slack on Monday and find a half-finished agent demo still bound to a shared host. Nobody can say which prompt the agent used, which tool it called, or who may restart the box. The weekend volunteer already hopped onto another ticket, and the channel holds only a screenshot of a green check. You need a handoff that names owners before the next person types a destructive command.

This page is a paste-ready SOP for that Monday, not another glossary of agent slang. You will assign four role cards, freeze unspoken assumptions, and run a one-page wiki checklist before anyone touches the shared lab. The artifact is deliberately boring: YAML role cards, a markdown run, and a small Python gate that fails when the handoff is incomplete. If you strip every product name from this workflow, the checklist should still stop a confused restart.

The Monday failure this playbook targets

Shared AI labs fail in a social way long before they fail in a numeric way. Someone pastes a clever agent loop into a free host, the loop quietly fills missing specs, and the next person treats those guesses as policy. You then inherit a running process, an undocumented tool allowlist, and a chat log that never recorded who approved the guess. Role cards exist so the guess has a human owner instead of a screenshot.

You should use this SOP when two or more people share a coding agent, a prompt file, and a long-lived server. You should not use it as a substitute for real access control, secrets management, or production change review. The goal is a wiki page that a tired teammate can execute without rereading the weekend thread.

Four role cards you pin above the runbook

Give every shared lab four named humans, even when the same person wears two cards for a week. Write the names in the wiki, not in a private message that disappears after the sprint. Rotate on a calendar you already use, because a clever new rotation tool will itself need a handoff.

1. Assumption Owner — the person who must write down every fact the agent invented, including paths, IDs, and default models.
2. Server Steward — the person who may start, stop, or reprovision the shared host, and who posts the new endpoint.
3. Prompt Librarian — the person who versions the system prompt, tool list, and any MCP-style connector notes in git.
4. Handoff Receiver — the person who will be awake at nine, who must reject the lab if any required field is still TBD.

You keep the cards short so people actually wear them. You do not invent a fifth coordinator unless two teams share the same host and already collide. If a role is vacant, you treat the lab as frozen, which is safer than letting the agent keep assuming.

One-page wiki run you can paste today

Copy the block below into your team wiki and fill the backticks during the last thirty minutes of a spike. Speak in commands and file paths, not in vibes about how well the agent seemed to behave. The receiver should be able to replay the lab from this page without opening the original chat.

# Shared AI lab handoff
Date (UTC): YYYY-MM-DD
Spike title:
Repo + commit:
Prompt path:
Tool/MCP list path:
Host name / URL:
Process manager (systemd, docker, other):

## Role cards
- Assumption Owner:
- Server Steward:
- Prompt Librarian:
- Handoff Receiver:

## Assumptions the agent made (must not be empty)
- [ ] Invented file path or module name:
- [ ] Invented environment variable:
- [ ] Invented “safe default” in a tool call:
- [ ] Invented user, tenant, or dataset identity:

## Freeze / thaw
- Freeze command:
- Thaw command:
- Who may thaw:
- Secrets location (not the secret itself):

## Monday first hour
1. Receiver reads assumptions aloud.
2. Steward confirms the process is stopped or pinned.
3. Librarian diffs prompt and tool list against main.
4. Owner files tickets for every remaining guess.
5. Receiver signs the wiki page or rejects the lab.

You treat an empty assumption list as a failed handoff, not as proof the agent was careful. Agents hide guesses inside default arguments, and those guesses travel farther than a chatty system prompt. If you cannot name a guess, you probably have not looked at the tool trace yet.

Numbered run for the last half hour of a spike

Follow the steps in order even when the demo looks healthy. A green check on a shared host is not a transfer of ownership. You are buying a clean Monday, not extra minutes of model output.

1. Stop generating. Ask the agent for a tool trace and save it beside the prompt file.
2. Fill the four role cards. If a name is missing, freeze the host and end the spike.
3. Walk the trace with the Assumption Owner and write every invented default as a bullet.
4. Ask the Prompt Librarian to commit prompt, tools, and the trace with the same message.
5. Ask the Server Steward to pin or stop the process and paste the exact freeze command.
6. Ping the Handoff Receiver with the wiki link only, not a stack of screenshots.
7. Receiver replies ACCEPT or REJECT on the wiki page before logging off.

You should keep the freeze command copy-pasteable. A steward who must reconstruct flags from memory will reconstruct them wrong. Put the command in the wiki even if it looks too simple to document.

Artifact: role file plus a gate that fails incomplete handoffs

Store the living names in git so the wiki and the repo cannot drift for a week. The YAML below is a template, not evidence from a particular company, so label it as a proposal you will edit. Keep secrets out of this file; it only names people and paths.

# handoff.yaml — proposal for a shared AI lab
spike: "weekend-agent-demo"
repo: "your-org/your-lab"
commit: "REPLACE_ME"
prompt_path: "prompts/system.md"
tools_path: "prompts/tools.json"
host: "shared-lab.example.internal"
roles:
  assumption_owner: "REPLACE_ME"
  server_steward: "REPLACE_ME"
  prompt_librarian: "REPLACE_ME"
  handoff_receiver: "REPLACE_ME"
assumptions:
  - "Agent created app/router_v2.py without a ticket."
  - "Agent set REQUESTS_TIMEOUT=3 as a silent default."
freeze_command: "docker compose -f lab.yml stop agent"
thaw_command: "docker compose -f lab.yml up -d agent"
who_may_thaw: "server_steward"
receiver_decision: "PENDING"  # ACCEPT | REJECT | PENDING

Save the checker next to the YAML and run it in the same working tree. The script only validates structure and forbidden placeholders; it does not claim to understand your agent. You still need a human to judge whether an assumption is real.

#!/usr/bin/env python3
"""Fail a shared-lab handoff when role cards or assumptions are still blank."""

from pathlib import Path
import sys
import yaml

REQUIRED_ROLES = (
    "assumption_owner",
    "server_steward",
    "prompt_librarian",
    "handoff_receiver",
)
BANNED = {"", "REPLACE_ME", "TBD", "TODO", None}


def main(path: str) -> int:
    data = yaml.safe_load(Path(path).read_text())
    errors = []

    roles = data.get("roles") or {}
    for role in REQUIRED_ROLES:
        if roles.get(role) in BANNED:
            errors.append(f"role {role} is unnamed")

    assumptions = data.get("assumptions") or []
    if not assumptions:
        errors.append("assumptions list is empty")
    for item in assumptions:
        if item in BANNED:
            errors.append("assumption placeholder still present")

    for key in ("freeze_command", "thaw_command", "prompt_path", "tools_path"):
        if data.get(key) in BANNED:
            errors.append(f"{key} is unset")

    decision = data.get("receiver_decision")
    if decision not in {"ACCEPT", "REJECT", "PENDING"}:
        errors.append("receiver_decision must be ACCEPT, REJECT, or PENDING")

    if errors:
        print("HANDOFF INCOMPLETE")
        for err in errors:
            print(f"- {err}")
        return 1

    print("HANDOFF STRUCTURE OK — receiver still must read the wiki")
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv[1] if len(sys.argv) > 1 else "handoff.yaml"))

Run it locally before you ping the receiver. Keep the command in the same wiki page as the role cards so nobody hunts through chat history.

python3 -m pip install pyyaml
python3 check_handoff.py handoff.yaml
echo $?  # 0 means structure only; humans still accept or reject

If the checker exits nonzero, you do not thaw the host. A missing name is cheaper to fix on Sunday night than after someone restarts the wrong container. You can wire the script to a pre-push hook later; do not wait for CI philosophy before using it by hand.

Where a free shared lab fits, and where it does not

You can rehearse this SOP on any disposable host your team already shares. A dedicated free coding environment helps only when you want the roles to collide in a realistic way without burning a paid quota during practice. Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode currently offers free model access and a free server option, which you can use as the shared lab while you learn the four-card handoff. Do not treat that option as an SLA, a capacity plan, or a promise about named models, hardware, or how long the tier lasts.

If you try the dry run there, still keep prompts, traces, and role YAML in your own git remote. A free server is a place to execute, not a place to store the only copy of who owned the last guess. When the practice spike ends, the Server Steward should freeze the process with the same command you documented, even if nobody is waiting on Monday.

Limitations, and who should skip this SOP

This playbook will annoy a solo developer who already owns every file and every reboot. It will also fail a regulated workload that needs ticketed change control, because a wiki page is not an audit log. You should skip it when the agent can reach production data, customer secrets, or networks you do not fully control.

The Python gate cannot see lies. An Assumption Owner can write a cheerful bullet that hides a worse default inside a tool schema. The Handoff Receiver still has to read the trace, not only the YAML keys. If your traces are truncated, you do not have a handoff; you have a story about a handoff.

Free shared hosts also disappear, throttle, or change behavior without a meeting. You should not put customer traffic, cron that must hit a wall clock, or irreversible migrations on that class of machine. Use the lab to practice ownership, then promote the same role cards onto whatever paid environment your team already trusts.

Close the loop on Tuesday, not in the retro two weeks later

On Tuesday, look at the accepted page and file one ticket per remaining assumption. Convert invented paths into real design notes, or delete the files the agent created without permission. Then rotate at least one role card so the same person is not forever the only adult in the lab.

You will know the SOP is working when a spike can end with REJECT and nobody takes it personally. A rejected lab is a successful handoff, because the next person refused to inherit a guess. Keep the page to one screen, keep the checker strict, and let the agent stay silent until a named human owns what it assumed.