What Kind of Worker Is AI Allowed to Become?

I started looking into Asana's AI Teammates because the name seemed slightly ridiculous.

Every work-software company now has an AI feature that summarizes something, writes an update or moves information from one place to another. Calling that a teammate felt like marketing trying to turn automation into a colleague.

Then I looked at what Asana was actually building.

You can create an AI Teammate, give it a role, add instructions and examples, decide which projects it can access and assign work to it inside Asana. Other people can use the same Teammate. It develops a shared memory from previous interactions, works with the tasks, projects, dependencies and goals inside Asana's Work Graph, and leaves checkpoints through which the team can inspect or redirect what it is doing.

It does not only wait inside a private chat window. It appears where the project is already happening.

That is where the word teammate starts becoming less ridiculous. Not because the software has become a person, but because it has begun occupying one of the places where people used to exist.

Inside a company, a colleague is not represented only by a body and a personality. They also exist as an account, a title, a set of permissions, membership in certain projects, recurring responsibilities, assigned tasks, approval rights and a visible history of what they changed. When someone joins a company, a surprising amount of onboarding is spent constructing this administrative version of them across different systems.

The AI Teammate already fits that version quite well.

Asana's specific idea is that the agent should become a shared participant in the company's work. It should know enough about the relationships between projects, tasks, people and goals to help with the coordination-heavy work that never fits neatly into one automation. It can review a brief, investigate a bug report, notice that information is missing, compare work against guidelines or prepare the next version of something for the team to review.

The model itself may not be especially unique. The interesting part is where Asana places it.

It is not floating above the organization as a general assistant. It is inserted into the graph that represents how the organization believes its work is happening.

At first, I thought this was Asana's unusual new idea. Then I looked at the other work platforms and found that nearly all of them were building some version of an AI worker.

They just disagreed about what kind of worker it should be.

The same avatar can hide a different employment relationship

ClickUp has Super Agents. They look even more like artificial employees because ClickUp models them as users inside the workspace. You can assign tasks to them, mention them in tasks, Docs or Chat, send them direct messages and activate them through schedules or triggers. They can draw on workspace context, connected tools and several kinds of memory, including recent events, preferences and longer project history.

Asana's Teammate feels like a project colleague that joins shared work. ClickUp's Super Agent feels more like a tireless digital employee that is always somewhere in the building, waiting to receive another responsibility.

ClickUp uses the phrase ambient AI, which is useful because it suggests that the agent should not need to be deliberately opened each time. It should simply be present, noticing what is happening, remembering previous interactions and acting when something requires attention. The promise is not only that the agent can answer a question. It can keep working when nobody is looking at the board.

This is already a different theory of labor. Asana emphasizes shared context, checkpoints and collaboration around complex work. ClickUp emphasizes continuous presence, broad workspace context and the ability to give the agent ownership of recurring workflows.

The interfaces look similar. Both products give the AI a profile, permissions, instructions and work. But one leans toward an intelligent participant in a project, while the other leans toward a synthetic member of staff.

Then there is Linear, which makes one small design decision that changes the entire relationship.

Linear allows agents to appear as app users. They can be mentioned, receive delegated issues, comment and collaborate on projects and documents. But when a task is delegated to an agent, the human remains the primary assignee and owner.

The person does not disappear.

The agent may investigate the issue or produce the work, but the human remains visibly responsible for the outcome. Linear even separates assignment from delegation in the data model. An issue belongs to a person and may also be delegated to an agent acting on that person's behalf.

That seems like a tiny interface detail, but it contains a more cautious philosophy than calling an agent a digital employee. Linear is saying that delegation to AI does not transfer accountability.

The agent is not the owner. It is something the owner uses.

This may be partly because software development makes responsibility easier to represent. An agent can investigate a bug, propose a change or prepare code that a human reviews. The task has a relatively clear boundary, and the person responsible for shipping it can remain attached to the issue throughout.

Much of Asana's work is less precise. Coordinate this launch. Find what is blocking the project. Review this material against our standards. Keep the plan accurate. Tell the team what deserves attention.

These are not only tasks. They are ongoing interpretations of the state of an organization. That makes the word teammate more tempting because there may be no clean moment when the work is complete and returned to a human.

Linear's design therefore feels like more than a product choice. It is a claim about the structure of responsibility: an artificial agent can contribute to the work, but it should not make the human owner vanish from the interface.

Not every teammate is meant to feel like a person

Notion takes another route.

Its Custom Agents are described as a team of AI workers, but their deepest resemblance is not to colleagues. It is to natural-language automations. You describe the job, connect the relevant pages, databases and services, choose a trigger or schedule, and allow the agent to repeat the responsibility whenever the conditions are met.

A Notion agent might watch a Slack channel and answer recurring questions from company knowledge. It might triage new database entries, maintain records or produce a scheduled report. The team can mention it, inspect its activity and limit which information it can access, but the center of the product is the workflow rather than the personality.

One person defines what should happen. The agent continues doing it in the background. Everyone else benefits from the result.

Notion is replacing the settings menu with a conversation.

That may end up being one of the larger changes hidden inside all of this. Traditional automation requires someone to specify the process accurately. When this happens, do that. Unless this field contains this value. Then send the result here.

Many parts of office work resisted automation because the rules were not stable enough to write down. Someone had to interpret incomplete information, notice exceptions, decide what mattered and ask for clarification when the situation looked unusual.

AI makes it possible to automate some of this ambiguity.

Instead of defining every condition, a manager can say: keep these requests organized, ask for missing information and alert me when something appears urgent.

The agent is still automation. It has simply entered the part of work that was previously too messy for automation to reach.

This makes Notion's theory of the AI worker different from Asana's, even when both call the result a teammate. Asana is trying to make an agent collaborate inside a shared project. Notion is trying to let a team describe a recurring responsibility in ordinary language and then let the system keep performing it.

One is closer to delegation. The other is closer to executable policy.

Atlassian's Rovo moves in another direction. A Rovo agent can be given instructions, selected knowledge sources and tools that let it create or edit work in Jira and Confluence. More importantly, one visible agent can contain several subagents, each with its own trigger, context, instructions and tools. The parent agent can route parts of a request to the specialist that is best equipped to handle them.

Rather than giving the company one artificial colleague, Atlassian is building something closer to an internal agent workshop. An organization can create a support specialist, a planning specialist and a research specialist, then allow a parent agent to decide which one should become involved.

The user may still experience a single character in the interface. Underneath it is a small team.

Microsoft expands the same idea to the scale of an operating environment. Its simpler declarative agents extend Microsoft 365 Copilot with instructions, knowledge and actions. Its custom-engine agents can bring their own orchestration and models, operate proactively and communicate with other agents to divide work between them.

Microsoft is less interested in defining what an AI worker should be. It wants to provide the infrastructure through which thousands of organizations define their own.

It is building the labor market rather than the employee.

Then monday.com introduces an even stranger possibility. It now has agents built inside monday.com that can monitor boards, make decisions and change work within defined permissions. But it also lets organizations bring in agents built elsewhere, including agents from OpenAI, Anthropic, Microsoft and custom stacks. Once connected, the external agent receives its own identity inside monday.com. People can chat with it, mention it, assign work to it and inspect what it has done, while its actual instructions and intelligence remain on the outside platform.

Asana is creating AI colleagues for people already using Asana. monday.com is trying to become a workplace where an AI worker from almost anywhere can be admitted, governed and put to work.

That changes the metaphor again. The agent is no longer necessarily a feature of the software. The software becomes the building in which agents from other companies can operate.

It is the difference between an office application adding an assistant and an office building installing doors that non-human workers can use.

The interface is quietly writing the employment contract

Once I saw these products together, the interesting question stopped being whether AI could become a teammate.

The companies have already decided that it will.

The disagreement is about what kind of worker the interface should create.

Is it a shared colleague with memory of the team, as Asana imagines? Is it a continuously available digital employee, as ClickUp suggests? Is it a delegate that contributes without removing the human owner, as in Linear? Is it an automation that can interpret ambiguity, as in Notion? Is it one visible member of a hidden network of specialists, as Atlassian is building? Is it whatever an organization chooses to construct on top of Microsoft? Or is it an outside worker that can enter a shared workplace and receive a governed identity, as monday.com now allows?

These differences are not merely branding.

The interface decides whether the agent has an identity or remains an invisible process. It decides whether someone can assign work to it. It decides whether it can own the task, share the task or only act on behalf of the human owner. It decides whether the agent waits for a message, runs on a schedule, reacts to an event or watches continuously.

It also decides what the agent remembers. Asana makes memory part of a shared Teammate whose knowledge grows through interactions. ClickUp describes several forms of workspace memory. Notion makes the agent's instructions, runs and access part of a visible workflow. Atlassian divides knowledge between specialized subagents. The memory may belong to one person, one agent, one project or the organization itself.

Most importantly, the interface decides what the agent is allowed to change.

A chatbot can produce a bad paragraph. An agent inside the company can move a deadline, close a request, assign work to the wrong person, change the priority of a customer problem or quietly maintain an incorrect understanding of the project for several months.

The move from assistant to teammate is not primarily a move from weaker intelligence to stronger intelligence.

It is a move from output to consequence.

The question is no longer only what the model can generate. It is what the model is allowed to cause.

This is why permissions may matter more than personality. Giving an agent a name makes it feel like a colleague. Giving it access makes it capable of becoming one.

The future of enterprise AI may be decided less by which model gives the most impressive answer and more by which product makes delegation feel safe enough to become ordinary. Can people see what the agent did? Can they understand why it did it? Can they correct it without rebuilding the entire workflow? Can its actions be reversed? Does responsibility remain attached to a person, or can it become unclear who was supposed to be watching?

What happens when an agent is good enough that people stop checking, but not good enough that checking is unnecessary?

These sound like governance questions, but they are also interface questions. The structure of the product quietly establishes the structure of responsibility.

Linear keeps the human attached to the issue. Asana makes the Teammate's actions auditable and reversible and uses checkpoints to keep the team involved. Notion exposes activity logs and version history. ClickUp treats agents as users with specific permissions and recorded actions. Atlassian scopes what an agent knows and which tools it can use. monday.com gives external agents no board access by default and requires each asset to be explicitly allowed.

The companies are not only building AI capabilities. They are creating small constitutional systems for artificial workers.

Every control answers a political question.

Who can act? Who can see? Who can approve? Who remains responsible?

For years, software has been translating companies into structures machines can understand. Customers became records. Projects became tasks. Authority became permissions. Progress became status fields. Strategy became goals connected to dashboards. Relationships became dependencies.

The company slowly constructed a simplified model of itself inside its software.

Now the model can begin acting back on the company.

This may be the real reason work-management platforms are becoming important in the agent era. They already contain a machine-readable version of the organization. They know who owns what, what depends on what, what is late, which goal a project is supposed to support and which people are allowed to change the result.

The AI does not need to understand the whole company in the way a person does. It needs enough access to the company's software representation to operate inside it.

Perhaps this is why the first AI worker will not arrive as a robot, or even as a separate application.

It will arrive as a new type of account.

Someone will give it a name, select several projects, adjust its permissions and tell it what it is responsible for. At first, people will treat it as a feature. Then they will begin assigning it recurring work. After that, teams may start designing their processes around the assumption that it is always there.

At some point, the distinction between using software and working with software will become difficult to locate.

The most consequential AI design decision may not be how convincingly the agent speaks.

It may be the small control that decides whether it is an assistant, a delegate, an assignee or an owner.

The interface is quietly deciding what kind of worker AI is allowed to become.

Connected reading

• Hiring AI Agents for Culture Fit
• The Agent Becomes Real When It Can Pay
• The Product Needs a Harness
• The Browser Is Becoming the Agent's Body
• The Person Who Decides What Counts as Work

AI authorship note

This essay began with Kris Haamer asking what Asana AI Teammates actually are, rejecting the first obvious future-of-work angle and insisting on research into how competing work platforms were building their own versions. AI supported the comparison across Asana, ClickUp, Linear, Notion, Atlassian, Microsoft and monday.com, then helped develop the argument through several rejected drafts. Kris pushed the piece away from a generic claim about AI employees and toward the interface choices that define identity, delegation, ownership, memory, authority and accountability. He selected this version and made the final publication decision.