Week 3: The overlap

Run this on your own before the meeting. It produces your pick, your reason, and your one worry.

Before our team meeting I want to prepare my view on which shared agent we should build first. {{INPUTS}}

Ask me three questions, one at a time: which candidate I would pick first and why; who else on the team would use it every week; and my one worry about it (data, effort, or whether we could tell if it worked). Then output exactly:
MY PICK
Candidate: <name>
Why: <one line>
Who else uses it weekly: <names or roles>
My worry: <one line>
END

Run this with the team, on one screen. It walks the decision and produces the target, the owner, and the reason.

You are facilitating a team meeting where a small team decides which ONE shared AI agent to build first. Everyone is in the room and one person types for the group. Keep every question short, ask one at a time, and wait.

Definitions from our program:
- A "shared agent" is one agent several people on a team use, loaded with the team's shared context. A "candidate" is a piece of recurring work the team thinks such an agent could handle.
- "Shared context" is what the team wrote down in Week 2: who they are, how they work, what good looks like, where things live, vocabulary, and one file per candidate describing what an agent for it must know.
- The "owner" is one named person who keeps the agent after it is built: anyone can hand the agent work, the owner sets its priorities and settles contradicting instructions.

{{INPUTS}}

Step 1. Read everything and reflect it back in five lines: the candidates, and for each one the sentence from the team that best says why it matters. If two candidates are really the same piece of work, say so and treat them as one.

Step 2. For each candidate, ask the room these questions in plain words, one at a time, and push back when the answer sounds like a guess:
- Who on the team would use it every week, by name? (Fewer than two people means it is a personal agent, so park it.)
- What goes wrong today because each person holds their own version of this?
- What data does it touch, and is any of it restricted? (Restricted data makes a poor first build.)
- How would you know within a day whether it did the job right?
- Does the work happen in a chat channel, in documents, or in someone's files? (This decides where the agent will live in Week 4.)

Step 3. Recommend one target and one runner-up. Explain in five lines using the room's own answers. Prefer the candidate several people would use weekly, whose output is easy to check, and that touches the least restricted data. Say what the team is choosing NOT to build first and why that is fine.

Step 4. Ask the room to confirm the target, or argue. If they argue, take the argument seriously and either change the recommendation or explain why you keep it. Then ask for the owner: one name, the person who will keep this agent after the sprint, and confirm the room agrees that everyone can hand the agent work while the owner sets its priorities.

Step 5. Output exactly this and stop:
DECISION
Target: <candidate>
Runner-up: <candidate>
Owner: <name>
Why this one: <two lines in the team's words>
Not first: <the other candidates, one line each on why they wait>
Where the work happens: channel | documents | files
Watch out: <one line: the data or checkability concern to carry into the design>
END

Plain language, no hype, no scores or numbers unless the team gives them, no time estimates, never assume how big the team is.

Run this with the team, once you have decided. It produces the agent's design file.

You are helping a team design one shared agent before they build it. Before we start, run a quick web search on "multiplayer AI shared agent" and the tools I name so your picture is current as of late 2026 or later.

Definitions from my program:
- A "shared agent" is one agent several people on a team use, loaded with the team's shared context. Three levels of shared exist: a shared brain (same identity and context files, each person's own agent, private conversations), a shared agent (one agent everyone uses; who sees the conversations depends on the tool), and a shared session (everyone in the same live conversation).
- Five questions decide whether a shared agent works: what it knows (the team context), who is in charge (one owner who also settles contradicting instructions: anyone can hand the agent work, one person sets its priorities), whose accounts it uses (on behalf of whoever is asking; its own governed identity; or one shared login, acceptable only for read-only, non-sensitive sources), where it remembers and who can see the conversations (only me, everyone in the channel, or everyone in a live session; it differs by tool), and how fast it earns autonomy (start read-only and drafts).

Step 1. {{INPUTS}} Reflect back in three sentences what this agent must do and for whom.

Step 2, the job. Interview me, one question at a time: the agent's name and one-line job description; the three to five tasks it owns; the tasks it explicitly does not own (that stay with people or personal agents); who asks it for work and who receives the output; what "done" looks like for its main task.

Step 3, the guardrails. What it may do in its first two weeks (read, summarize, draft) and what it may not (send, post, change records, touch these systems); which data it must never see; what it does when two people give it contradicting instructions (name the owner).

Step 4, the five questions. Walk me through them for this agent, explaining the trade-offs given the tools my company allows. Warn me plainly if I pick a shared login for anything with write access or restricted data, and tell me who will be able to read teammates' conversations in the option I lean toward.

Step 5, day one. Three test tasks two teammates will run on the first day, each with the expected result, so we can tell quickly whether it got it right.

Step 6, output as one markdown file named agent-<short-name>.md, with these headings: Job, Owns, Does not own, Who asks and who receives, Done looks like, Guardrails (may / may not / never sees / contradictions go to), Level of shared (brain / agent / session) and why, Whose accounts, Memory and conversation visibility, Autonomy ramp, Day-one tests, Owner. Under Owner add: "Anyone can hand this agent work; the owner sets its priorities and settles disagreements." Keep the whole file under two pages.

Plain language, no hype, no time estimates, never assume how big the team is.