Imagine someone new joins your team on Monday.
They have no desk. They never appear at the office. They receive no salary. They can work overnight, run several tasks at once, and post updates in a Slack channel.
They are assigned a problem. They ask a few questions, prepare a change, and wait for someone to review the result.
The scene leaves us with a strange question: are we using a tool, or are we working with a new kind of coworker?
For the last few years, our relationship with artificial intelligence has mostly been private. One person talked to a chatbot. A programmer used a copilot. The result might eventually reach a document, repository, or presentation, but the interaction that produced it remained trapped on one screen.
Agents are now beginning to leave that individual space and enter the places where teams coordinate work. I think this change matters more than any single product announcement suggests. When AI stops assisting one person and starts participating in a shared process, more than the tool begins to change.
The organization begins to change too.
First we talked; then we began to delegate
Many people's first experience with generative AI was asking a question and receiving an answer. A model could explain, summarize, write, or help us think, but we still performed most of the work.
Then copilots arrived. In programming, AI entered the editor, observed the code, and began completing lines, proposing functions, or explaining errors. The assistance became more intimate, although the relationship remained clear: the person was driving and the AI was helping.
The word copilot described that boundary quite well.
Agents changed the unit of work. We no longer ask only for a sentence or a function. We give them an objective:
“Research this problem.”
“Fix this error.”
“Prepare a proposal.”
“Implement this feature and verify that it works.”
To respond, an agent may explore files, search for information, use tools, run commands, compare results, and return with something that claims to be finished. We do not necessarily participate in every step.
That is where delegation begins.
For now, much of that delegation still happens in private. A person opens an agent on their computer, provides context, and watches it work. The rest of the team sees the final change, but may never know the instructions, the discarded paths, or the mistakes made along the way.
It is like having a private assistant that helps produce more, while its work disappears when the session closes. Individual productivity can grow while the knowledge remains locked inside a conversation nobody else can inspect or reuse.
When the agent enters the channel
Slack Code is an interesting signal of what may come next. Its proposal is to create temporary channels where people and agents work around the same task. Context carries over from an earlier conversation; the agent publishes updates and artifacts; other people can join, comment on changes, add information, and approve the result.
This is more than bringing a chatbot into Slack. The agent's work becomes visible and shared.
A private agent belongs to one person's workflow. An agent working in a channel begins to belong to the team's workflow.
Slack describes sessions that can display code diffs, documents, and HTML prototypes, with statuses showing whether the agent is working, blocked, or waiting for a response. The feature is still rolling out gradually and supports a limited set of agents. It is too early to know how much it will change real work.
But the direction matters more to me than the product's current maturity: AI is beginning to occupy a visible place in coordination.
Warp proposes another shift with Factories. Instead of leaving every agent on an individual laptop with one person's permissions, it proposes moving those workflows into shared cloud environments. A task can pass through separate stages: triage, specification, implementation, review, and verification. Each stage may have its own agent, tools, and permissions, while people retain key decision points.
This is also a very new proposal and is currently in closed beta. Its claims should be read as claims from the company selling the product, not as evidence that every organization already works this way.
Even so, it reveals something useful. The agent begins to have an environment, a role, a history, and defined limits. It stops being a hidden capability inside someone's computer and starts becoming a unit of execution the organization can observe.
Not a person, but not a button either
This is where we should slow down the coworker metaphor.
An agent has no life, needs, or moral responsibility. It feels no pride when it succeeds and no guilt when it causes a problem. It can produce a convincing explanation without understanding the consequences of what it is doing. If we imagine it as a digital person, we risk attributing judgment, intent, and understanding where there is only a system responding to goals, context, and rules.
But treating it like a button is not enough either.
A button waits for a specific command and performs a predetermined action. An agent receives an objective, divides the problem, chooses steps, and uses tools that can affect systems and people. It has no will of its own in the human sense, but it does exercise capacity someone delegated to it.
Perhaps we need an intermediate category: a software actor inside the organization.
It is not an employee. It is not a colleague in the emotional or legal sense. It is a system capable of intervening in a shared process. Once we give it the capacity to act, the conversation stops being only about intelligence.
It becomes a conversation about authority.
The question is no longer just whether it answers well
With a chatbot, we usually ask whether the answer is correct. With an agent participating in real work, that is only the beginning.
Who can assign it tasks? What information does it receive? Can it access customer data? Modify a database? Deploy code? Send messages on behalf of the company? Spend money? When must it stop and ask for help?
Above all, who answers when it makes a mistake?
The agent cannot take responsibility. Responsibility remains with the people and organizations that decided where to use it, which permissions to grant it, and which checks to require before accepting its work.
This becomes even more complicated when several agents are involved. One agent can increase one person's capacity. One hundred agents without coordination can create one hundred new sources of noise: duplicating tasks, contradicting one another, producing incompatible changes, or generating more material than the team has time to review.
They may even make decisions that are locally reasonable but collectively absurd.
That is why buying access to more capable models is not enough. Organizations need roles, permissions, limits, validation mechanisms, and moments when a person must intervene. In other words, they need to design the work system in which human and artificial actors coexist.
Production may stop being the bottleneck
For a long time, production was the scarce part: writing the code, preparing the document, analyzing the information, or building the prototype.
If each person can direct several agents, that scarcity moves.
A team may generate fifty proposals in the time it once generated five. But someone still has to decide which ones make sense. It may produce ten times more code, but someone must understand it, test it, and take responsibility for putting it into production. It may create one hundred campaigns, but it still needs to recognize which one truly represents the company.
Cheap code. Scarce review.
Cheap content. Scarce attention.
Cheap options. Scarce judgment.
Human work may not disappear overnight. It may shift—from executing every step to defining objectives, providing context, establishing limits, reviewing consequences, and making decisions.
That does not automatically make work easier. Directing systems that produce at great speed requires framing problems well, recognizing a bad answer even when it is presented confidently, and knowing when to stop a process before its speed multiplies the error.
Our capacity to make things grows. So does our responsibility to choose.
What happens to the work through which we learned?
Another consequence worries me in particular.
A small team assisted by agents may be able to build things that once required a large organization. That can free time, reduce repetitive work, and give people and small companies capabilities they could never have afforded before.
It may also eliminate jobs, especially entry-level roles made up of tasks that are easy to delegate.
That leaves us with a difficult question: if we automate the tasks through which someone began learning a profession, how do we develop tomorrow's experienced professionals?
A senior professional was not born senior. They learned by doing small jobs, making mistakes, receiving corrections, and observing other people. Routine tasks were not always exciting, but many served as training grounds.
We can improve today's productivity while weakening the way we build experience for tomorrow.
Companies will need to design learning opportunities deliberately. Newer professionals may not do the same manual work as before, but they still need to participate in defining, reviewing, and diagnosing what agents execute. If they receive only finished results, they risk becoming supervisors of processes they never learned to understand.
Adopting agents is not only a decision about what to automate. It is also a decision about where people will continue to learn.
The organization is the real interface
I do not know whether Slack Code or Warp Factories will be the products that define this stage. Both may change, be replaced, or fail to deliver on every promise. Technology demonstrations always move faster than the everyday transformation of a company.
But the idea they represent feels more durable.
We are moving from the private copilot to the visible agent. From one person using a tool to a team coordinating human and artificial actors. From improving an individual task to redesigning how context, authority, and responsibility move through an organization.
In that world, the important question is no longer only how intelligent the model is.
It is what work we give it. Which systems it may touch. Who reviews its actions. How we preserve knowledge. Which mistakes we are willing to tolerate. And which decisions we want to keep, even if a machine may one day execute them faster.
Your next coworker may not be human.
But deciding what it can do, when to trust it, and who answers for the result will remain profoundly human.
References
- Slack Developer Docs, Announcing Slack Code, August 20, 2026.
- Slack, Build with AI as a team using Slack Code.
- Warp, Introducing Warp Factories, August 2026.
- Warp, How to Move from Coding Agents to a Software Factory, August 25, 2026.
This article grew out of a conversation I prepared for El Rincón de Sarreche, where I try to look at technology not only through what it does, but through what it changes around us. You can watch the original video on YouTube.