What “AI coworkers” mean (and what they don’t)
An AI coworker is not “general AI for everything.” It’s a role with a consistent scope and repeatable workflows — like a partnership manager, an “email bird dog,” or a meeting follow-up assistant — that helps reduce operational load by handling the same categories of work the same way, every time.
Good AI coworker tasks (high leverage + repeatable)
- Drafting first-pass replies to complex inbound emails, with links and next steps.
- Summarizing key changes in a pipeline or project and flagging risks.
- Turning meeting notes into checklists, SOP updates, or internal tickets.
- Monitoring a known set of systems and producing a daily/weekly digest (not continuous “always-on” browsing).
Bad AI coworker tasks (too risky or too fuzzy)
- “Decide what to do next” with no constraints.
- Anything that requires broad admin permissions “just in case.”
- Tasks that depend on private or sensitive data without a clear policy (PII, health info, credentials).
The 5-part system: Role → Permissions → Guardrails → Trigger → Review
1) Role: write a 1-sentence job description
Pick one job title and one outcome.
Examples:
- Partnership Manager Coworker: Keep partnerships current and remind the team about renewal dates, key contacts, and follow-ups.
- Email Bird Dog: Draft thorough email responses by pulling context from CRM, billing, and project notes.
2) Permissions: least access needed to do the job
Treat access the way you'd treat a new hire:
- Start with read-only access wherever possible.
- Grant write access only to specific databases/pages the coworker must update.
- Prefer “one database + one workflow” over “entire workspace.”
If your coworker needs tool context about your workspace, consider building its job around your existing systems (e.g., a client database + SOP database) rather than letting it search everything.
3) Guardrails: cost + token + model controls
Most “AI coworker” failures aren’t intelligence failures — they’re scope and cost failures.
Add guardrails in these categories:
- Budget & pacing: monitor Custom Agent runs and credit usage so spend stays predictable. Notion Custom Agents began charging credits starting May 4, 2026; admins can monitor usage in the Notion credits dashboard (Settings → Access & billing → Notion credits). For details, see: https://www.notion.com/help/custom-agent-pricing
- Token/cap limits: enforce “stop conditions” (e.g., max documents scanned, max messages drafted, max records updated per run).
- Model choice: use the smallest model that can do the job well. If you're approaching limits, switch down (e.g., Claude Haiku) for lighter tasks and reserve larger models for the hard parts.
- Escalation rules: when uncertain, the coworker should ask for clarification or create a review task — not guess.
4) Trigger: make execution explicit (no surprise automation)
A good AI coworker runs when:
- a specific property changes (e.g., “Status = Needs Reply”),
- on a predictable schedule (daily digest),
- or via a button/manual trigger.
Avoid vague triggers like “when anything changes.”
5) Review: keep a human in the loop (at first)
For the first version, ship with:
- Draft-only output (no sending, no publishing, no irreversible changes).
- A review checklist (below).
- A rollback plan (what gets reverted if it goes wrong).
Two concrete examples you can copy
Example A: Partnership Manager Coworker
Goal: Reduce dropped balls in partner relationships.
Inputs:
- Partner list (contacts, renewal date, last touchpoint)
- Notes from emails/Slack summaries
Outputs:
- Weekly “Top 10 partner follow-ups”
- Renewal reminders 30/14/7 days out
- A short status summary per partner
Guardrails:
- Read-only to email/Slack summaries; write access only to a “Partnership Tasks” database.
- Limit: max 25 partners reviewed per run.
Example B: “Email Bird Dog” Coworker
Goal: Reduce time spent writing long operational emails.
Inputs:
- CRM deal record (e.g., Pipedrive)
- Billing context (e.g., Stripe)
- Delivery documents (e.g., project docs)
Outputs:
- A structured draft reply: context, answer, next steps, links
Guardrails:
- Draft-only; never sends automatically.
- Limit: max 1 email thread per run unless manually triggered.
A lightweight governance model (simple, but real)
You don’t need a 40-page AI policy to start — you need consistent defaults.
Governance roles (minimum viable)
- Owner: accountable for outcomes and access (one person).
- Maintainer: edits prompts/instructions and monitors drift.
- Reviewer: approves outputs during the “training wheels” phase.
Governance artifacts (store these in Notion)
- A one-page “AI Coworker Spec” (template below)
- A permissions + data-access list
- A cost/pacing note (what to do if usage spikes)
- A changelog (what changed, when, and why)
Template: AI Coworker Spec (copy/paste)
- Name: (e.g., “Email Bird Dog”)
- Primary KPI: (e.g., reduce time-to-first-draft reply)
- What it does: (3 bullets)
- What it never does: (3 bullets)
- Inputs it can use: (systems + specific databases)
- Outputs it produces: (where drafts land)
- Trigger: (property change / schedule / button)
- Model default: (small model first; when to switch up)
- Limits: (records scanned, drafts created, max output length)
- Escalation: (what to do when uncertain)
- Owner / Maintainer / Reviewer: (names)
Launch checklist: ship your first internal AI coworker in Notion
Choose one role and one workflow to automate
Define the “never do” rules (privacy + safety)
Scope permissions (least-privilege)
Pick your trigger (explicit + testable)
Add cost/token limits (max records, max output length)
Decide model defaults (small first; scale up only when needed)
Set outputs to draft-only for the first iteration
Run 5–10 test cases and compare to human baseline
Create a simple review step for approvals/edits
Monitor usage weekly and tighten scope if needed
Get help building this
Building AI coworkers in Notion usually breaks at the permissions and guardrails step — scope creep is quiet until it's expensive. If you want a consultant to help you define the role, wire up the triggers, and set the cost controls, book a ZoomFlow session — one of our consultants can build the first version with you live and hand off a working spec before the call ends.
