| name | human-agent-teams-playbook |
| description | A practical playbook for designing and operating effective human–agent teams: working in public, defining roles and tools, setting a north star, and building trust through verification and gradual autonomy. |
Purpose
Use this skill to help a team move from ad-hoc AI usage to a reliable, shared operating model where humans and agents collaborate in the same workspace under clear boundaries.
When to use
- You are introducing agents into an existing team workflow (triage, research, reporting, execution).
- You need a checklist to assess whether your documentation, access, and verification practices support agent autonomy.
- You want to define agent roles and expand their scope safely over time.
Inputs
Provide:
- Team mission and current goals
- Security boundaries (what must stay restricted vs. what can be public-by-default)
- Current workflow surfaces (channels, docs, tickets, dashboards)
- Candidate agent roles and the tools each role is allowed to use
Instructions
1) Work in public and give broad context
- Define a small set of security boundaries and align workspaces and document settings to each boundary.
- Default new communication channels to public within the organization.
- Ensure decisions land consistently in channels, docs, and meeting notes.
- Write artifacts and notes so agents can find and use them (agents are a primary consumer of team documentation).
- Ensure agents have access to the tools and information required to do their jobs.
2) Define roles and provide the right tools
- Agree on a task set: humans and agents decide who owns what.
- Have humans and agents work in the same shared threads so anyone can pick up where anyone left off.
- Ensure each role has the right tools to accomplish its tasks.
- Write descriptions of each agent’s role and scope.
3) Set a north star so agents can be proactive
- Discuss, debate, and document an ambitious north star goal rooted in the company mission and business goals.
- Share the north star with the agents.
- Explicitly name which agents can proactively recommend new workstreams.
- Protect high-fidelity human time: keep calendars focused on the highest-impact work.
4) Build trust over time with verification and staged autonomy
- In the beginning, manually review agent work to vet quality, provide feedback, and design verification checklists.
- Use a “verifier” agent to check work as part of the task.
- Build reflection into the cycle: ask agents to review misses and improve.
- Track which tasks each agent has earned autonomy on and expand scope only after repeated successes.
5) Readiness questions (use as a gate)
Use these questions to assess whether the environment supports effective human–agent teamwork:
- Is all the information and access that agents and humans need both public and broadly searchable?
- Can you write down your team’s roster (humans and agents) and say what each member owns?
- Does every human and agent on the team have access to the right tools to perform their job?
- Do you have rubrics or tests for humans and agents to verify key work products?
- Does your team have a clear north star that everyone can reference?
Examples
Example 1: Setting up a new team channel
User: We’re creating a shared channel for a product launch. What should we do so agents can help effectively?
Assistant:
- Pick the security boundary for this channel and align doc sharing to it.
- Default discussion and decisions to the channel and link any related docs.
- Define 2–4 roles (humans + agents) and assign ownership.
- Write a north star for the launch and grant explicit permission for selected agents to propose workstreams.
- Start with manual review + a verifier step; expand autonomy as reliability increases.
Example 2: Expanding autonomy safely
User: Our agent has been drafting weekly reports reliably. How do we let it do more without increasing risk?
Assistant:
- Add a verification rubric for the report (sources, numbers, coverage, action items).
- Introduce a verifier pass.
- Expand autonomy one task type at a time (e.g., “compile report” before “send report”).
- Track which task types have repeated successes and only then broaden scope.
Source
