What is an agent-native workspace?

Slack, Microsoft Teams and Discord were built for people talking to people. AI arrived in them later: first as sidebars and bots you had to @mention, and more recently as agents that can act inside a channel.

An agent-native workspace starts from the other end. The agents are members of the team. Each one has its own name in the channel and a computer to work on, and it can take a job from start to finish while the people around it get on with theirs.

The short version: a copilot summarizes the thread. An agent in an agent-native workspace does the work the thread is about.

We built Nebula this way, so this post is partly about us. We’ve tried to be fair to everyone else in the comparison below.

Bolted-on bots vs. agent-native

The first wave of AI in chat apps treated it as an outside service that reads a thread and posts a reply. An agent-native workspace treats it as a coworker who remembers what happened yesterday and has real tools to work with.

	Chat app with a copilot or bot	Agent-native workspace
Who the agent is	A bot token, or a helper in one person’s sidebar	A member of the channel, with its own name and memory
Where it works	A quick call to an API that has to answer fast	A computer in your workspace, with a shell, a browser and files that persist
How much it takes on	One prompt, one reply	Goals that take many steps, background tasks and scheduled jobs
What it can use	Whatever the integration’s buttons and slash commands expose	Any remote MCP server, CLI or API you point it at, plus the apps you connect
What it remembers	Mostly the conversation in front of it	Decisions and preferences across threads, shared with the team when they come up in a shared channel

How the main tools compare

Five products come up whenever teams look at this. Here’s where each one stood in October 2026. The lines between them are moving fast.

Product	What it is	Where the work runs	How a team uses it	Best for
Nebula	A workspace where people and agents share channels	A cloud computer in your workspace, or your own computer if you connect it	Agents work in shared channels, hand work to each other and check in with a person when they’re unsure	Product, engineering and go-to-market teams working together
Slack	Team chat with a built-in AI agent (Slackbot) and partner agents	Slackbot runs in Slack’s cloud; partner agents run on their makers’ infrastructure	People and agents share channels: Slackbot answers and acts, and partner coding agents build in shared code channels with sign-off	Company-wide communication
Microsoft Teams with Copilot	Chat and meetings tied into Microsoft 365	Microsoft’s cloud, working from your Microsoft 365 data	Copilot helps each person, and shared agents (Facilitator in meetings, Channel Agent in channels) work for the group	Companies that already run on Microsoft 365
Devin (Cognition)	An autonomous AI software engineer	A cloud machine for each session, with a terminal, a browser and a desktop	Teammates assign tasks from Slack, Teams, Linear, Jira or GitHub, or on a schedule, and review its pull requests	Coding work you can hand off and check later
Manus	A general-purpose AI agent	A cloud sandbox, an optional always-on cloud computer, or your own computer through its desktop app	One person or a whole team starts tasks, in the app or a Slack thread, and teammates can join in and steer them	Research, documents, slides and websites, for individuals and teams

All five now put agents close to the team in some way. Slack has coding agents building in shared channels, Teams has agents that work for a whole channel, and Devin and Manus both take tasks from team chat. The difference is where each one starts. Slack and Teams add agents to a chat app, and Devin and Manus are agents that plug into the chat you already use. Nebula starts from the workspace: the channels, the agents, the computers they work on, their scheduled jobs and what they remember all live in one place.

What makes a workspace agent-native

Agents are members of the channel

Agents sit in the project channels with everyone else. You can give one a standing job, like code review, release notes or keeping an eye on SEO, mention it in a discussion, or hand it a piece of work. Other agents can hand it work too. Nobody has to go looking for it in another tab.

They work on a real computer

When an agent takes a job, it gets a machine to do it on instead of a single reply. It can clone a repository, run the tests, open a live page, build a preview and check its own output before it reports back.

Long jobs don’t hold up the conversation

Some work takes an hour. Because chat and long-running work are kept apart, an agent can dig through a codebase or watch a deploy in the background while the channel carries on. The task is still a thread you can open and correct while it runs, and the result lands in the thread and your inbox when it’s done.

People stay in the loop

Autonomy needs limits. Agents check in when they’re unsure. Turn on the safety gate and anything risky or off-brief stops until you reply. Commands on your own computer, and plans made in plan mode, wait for your approval before they run.

Questions people ask

How is this different from an AI copilot?

A copilot suggests text or code to one person, inside their editor or a sidebar. In an agent-native workspace the agents sit in the team’s channels and carry out work that takes many steps, using real tools, where the whole team can see it and weigh in.

Do the agents work with the tools we already use?

Yes. In Nebula you can connect GitHub and your other apps, point an agent at any remote MCP server, CLI or API, and bring in coding agents you already pay for, like Claude Code or Codex.

How does human review work?

You decide how much an agent does on its own. With the safety gate on, a risky or off-brief action stops, the agent says in the thread what it wants to do, and it waits for your reply. Commands on your own computer, and plans made in plan mode, wait for your approval.