Why I Put an AI Teammate on the Roster
I spent eight years running engineering teams, four of them fully remote. When Asana shipped AI Teammates, my first reaction was skepticism, not excitement. I have watched enough automation demos to know that “the agent assigns tasks” looks brilliant on a keynote stage and turns into a mess inside a sprint.
The pitch, though, was specific enough to test. Asana was not selling a chatbot that answers questions. It was selling an agent I could add to a project roster, assign work to, and hold to a definition of done. That is a different category, and it deserves a real trial.
So I ran a controlled experiment. I added an AI teammate to a live project, gave it a deliberately narrow permission scope, and tracked what it produced over two weeks. This article is that record: what worked, what did not, and what it actually costs a team that is thinking about handing work to an agent.
What Counts as an AI Teammate
Before the test, I needed to separate a “teammate” from a workflow rule. AI Teammates are agents you add to a project. They sit in the roster next to people, and you assign them tasks exactly as you would a colleague. You can set their role, scope their permissions, and decide whether their output needs a human check.
In practice, an AI teammate does four things well:
- Draft a task list and break a goal into subtasks
- Write a status update and summarize where work stands
- Propose assignments and due dates
- Flag blockers and surface risks before a human notices
The difference from a rule is judgment. A rule fires when a trigger happens; a teammate reasons about the task and returns a result you have to check. That is both the promise and the risk, and it is why you cannot treat an agent like a checkbox.
The Real-World Test: Three Task Types
I gave the agent three kinds of work over two weeks, each with a clear definition of done. Here is what came back.
| Task type | What I assigned | Output quality | Rework cost |
|---|---|---|---|
| Status summary | Draft a weekly progress note | Good, usable after light edits | 15 min |
| Task breakdown | Split a launch goal into subtasks | Mixed, needed reordering and a missing dependency | 45 min |
| Blocker triage | Identify risks on an active epic | Weak, missed Slack context and one dated assumption | 90 min |
The pattern is clear. For repetitive, well-documented work, the agent saved me real time. For ambiguous work that depends on context sitting in Slack threads and past decisions, it produced output I had to rewrite. This is the most important finding: AI teammates compress the cost of coordination, but they do not add context. When the context is already in the system, they win. When it lives in a human’s head, you pay for it in rework.
The Permission Boundary Is the Real Decision
This is the part most reviews skip, and it is where teams get hurt. When you add a teammate, you choose what it can touch. Asana’s model lets you scope the agent to specific fields, so the default is not “the agent edits everything.”
For a safe pilot, the minimum configuration looks like this:
- Read access to the project and its tasks
- Write access only to fields you want automated, like status, notes, and subtasks
- No access to fields you treat as source of truth, like owners, priority, and estimates
- Human approval before any assignment is committed to the timeline
The trade-off is genuine. Grant too little and the agent just reads, which makes it a dashboard. Grant too much and you spend your day repairing what it changed. In our experience, the safe middle is a narrow band, and it is worth the fifteen minutes to set it correctly.
Where It Fits in Your Tool Stack
An AI teammate is not a replacement for your project management process, and it is not a replacement for your chat tool either. It is a layer on top of both. In our stack it works best when it is wired into the same status fields you already maintain, so the agent’s summaries match what people actually look at.
The integration that surprised me was the handoff. When an agent flags a blocker, it lands in the project as a task, and a human takes it from there. That is the useful pattern: the agent surfaces, the human decides. If you skip that handoff and let the agent close the loop itself, you lose the chance to catch a wrong call early.
The practical setup that worked for us:
- Keep the AI teammate assigned to one project at a time
- Have it update the same status field your team already reads
- Route every blocker to a named human owner
- Review the agent’s weekly summary in your existing sync, not in a new meeting
What It Costs at 5, 20, and 50 Seats
I will be honest: the demo never answers the cost question, and it is the first thing a manager asks. Asana AI Teammates is priced as an add-on that scales with seat count, so the annual number depends on how many people you cover.
| Team size | Approx. annual add-on | What that buys |
|---|---|---|
| 5 seats | A few hundred dollars | One pilot project, one or two agents |
| 20 seats | Low thousands | Several agents, wider task coverage |
| 50 seats | Mid thousands | Agent use across most of the org |
The useful question is not whether it is cheap. It is whether the time saved exceeds the cost. On my numbers, a 20-seat team needed the agent to save roughly one hour per person per week before it broke even. That is achievable for status and triage work, but not for complex planning.
The Demo vs Production Gap
After two weeks, here is my honest read. Asana AI Teammates is a genuine step beyond workflow rules, and for a distributed team it removes real friction from status updates and task coordination. It is not, however, an autonomous colleague you can forget about.
It works best when you:
- Give it narrow, repetitive work with a clear definition of done
- Keep a human owner on every task
- Treat output as a draft, not a deliverable
- Review the audit log after each run
The agents that feel production-ready are the ones you have scoped tightly. The ones that fail are the ones you let loose on ambiguous, context-heavy work.
Which Teams Should Hold Off
I want to flag the counter-case, because the pitch is seductive. If your team’s work is dominated by ambiguous planning, long-running investigations, or decisions that require tribal knowledge, an AI teammate will not help. It will generate confident summaries that mislead.
Signs you should hold off:
- Your tasks rarely have a written definition of done
- Much of the context lives in Slack, not in the project system
- You cannot afford rework on the tasks you would delegate
If two of these apply, spend the money on better documentation first. The agent will still be there next quarter.
A Four-Step Plan to Pilot It Safely
If you want to test it without betting your sprint, use the plan I ran.
- Pick a low-stakes project. Choose one with clear tasks and no sensitive data, so a bad output costs little.
- Grant the minimum permissions. Give the agent only the fields it needs and keep editing rights with people.
- Run one task cycle. Assign a single task, let the agent draft output, then review it against your definition of done.
- Check the audit log and scale. Confirm every change, then expand to more tasks only after two clean cycles.
The single biggest predictor of whether an agent helps is a definition of done you can check. Before assigning work, write down what the deliverable looks like, which fields the agent may change, who reviews it, and what happens if it is wrong. That takes ten minutes and saves an afternoon of rework.
Is It Worth It for a Remote Team?
For a team spread across time zones, the appeal is obvious. An agent can summarize and triage while people are offline, so nobody has to wait for a daily call to find out where things stand. That is the strongest use case I found.
The evidence backs the coordination angle. According to McKinsey’s 2024 State of Remote Work report, employees who work remotely at least three days a week report 20% higher productivity, but only when coordination overhead stays low. AI teammates attack exactly that overhead.
The decision comes down to your task mix. If your project is mostly status updates, recurring coordination, and well-defined breakdowns, the AI teammate earns its keep. If your work is mostly ambiguous planning that depends on institutional context, keep the agent on the bench and automate only the few things it does well.
Either way, treat the first month as a pilot with tight permissions and an audit log, not as a full handover. That is how you find out whether the agent belongs on your roster for good.