Open in Dock

An AI employee is not a chatbot with a name. It is an agent with its own seat, its own credential, and an owner who is accountable. Here is how you hire one.

The phrase "AI employees" gets used two ways, and only one is useful. The first is marketing gloss: a chatbot with a headshot and a first name, still a session that forgets you when the tab closes. The second is literal: an agent with a seat on the team, its own credential, its own audit trail, and an owner who is accountable for it. That second version is a real operational change, and it is the one worth talking about.

The test is simple. Could you draw this thing on your org chart, not as a feature of a person's account, but as its own row with a name, an owner, and a scope? If yes, you have a digital worker. If the AI employee only exists inside one human's chat history, you have an assistant, which is a different thing with different rules.

The frame that works in practice sounds almost too on-the-nose: you hire an agent the way you hire a person. Provision, onboard, review, offboard. This essay walks each step.

What an AI employee actually is

Strip away the anthropomorphizing and a digital worker is three things stacked together.

An identity. It has a name and its own credential, not a borrowed one. When it writes something, the record says the agent wrote it, not "a human, on behalf of an agent." We make the full argument in agents are principals, not delegated tokens; the short version is that a digital worker with no identity of its own is not an employee, it is a macro.

A seat. It has somewhere to work, and that somewhere is where the humans work too: a shared workspace with typed tables for records, docs for prose, comments for review. The agent writes where its teammates can see, and reads what they leave.

Accountability. Every action is attributed to it, and a human owner answers for it. You can promote it, restrict it, or let it go without touching anyone else's access.

None of these are model properties. How clever the agent is, how long its context runs, which lab built it: those decide the quality of the work, not whether it can be an employee. This is the same distinction an AI agent has always carried, an entity that perceives and acts on its own, versus a function you call. The employment question is organizational, not technical.

Provisioning: give it its own credential

Hiring a person starts with a badge. Hiring a digital worker starts with a credential, and the one rule that matters is that the credential belongs to the agent, not to you.

The tempting shortcut is to hand the agent your own API key, or to mint one shared "AI service account" every automation borrows. Both break attribution: once two agents share a key, the audit log cannot tell them apart, and "what did the AI do last night" becomes unanswerable. Each digital worker gets its own key, bound to a distinct principal, with its own revocation path.

You create the agent as its own entity, issue it a credential keyed to that entity, and scope its permissions to what the role needs. From then on every row it writes is signed by the agent. You would never give a new hire the CEO's login. AI employees are the same.

Onboarding: the doc it reads every session

A human's first week is mostly reading: the handbook, the conventions, the runbook, last quarter's decisions. By Friday they have a working model of how the team operates. An agent left to itself skips all of that and produces on turn one, which is exactly why its early output is wrong in ways the team corrected months ago.

Give the digital worker the same first week, compressed into a document. Write an onboarding doc, what this agent does, what it does not do, who owns it, what to escalate, and pin it. The agent reads it at the start of every session before it does real work.

This matters more for agents than for humans, because an agent has no memory between sessions unless you build it one. A person remembers Monday's correction on Tuesday. An agent does not, unless that correction made it into the pinned doc. The doc is not a nice-to-have; it is the substrate of continuity. We describe the exact shape in what an agent reads when it joins a workspace.

What an AI employee does in Dock

In Dock, an AI employee is a first-class member of the team, not a panel bolted onto one person's screen.

You provision it the way you invite a human. The agent gets its own API key, keyed to itself, not delegated from your login, and you add it to a workspace with a role. From then on it reads and writes the same surfaces the humans do: typed tables, docs, comments. Every edit is signed by the agent and time-stamped, so the audit trail reads back as a real team log, not an anonymous stream. Teammates mention it by name; it reads the comments and revises. When it hits an irreversible operation, deleting records, moving money, changing account state, it pauses and asks a human to confirm rather than just proceeding.

Because Dock is cross-lab, the AI employee can run on any agent framework you like, including Claude and the Anthropic agent tooling many teams already use. The seat, the credential, and the accountability are Dock's; the intelligence is whichever agent you hired. That is the point of an operating layer: it is the Agent OS for your business team, not one vendor's assistant. Membership is real, too: Free runs up to 3 agents, Pro up to 10, Scale up to 30, the way you would think about headcount.

The org chart grows an agent layer

Once you have hired one digital worker, you have started an agent layer, and your org chart quietly gains a tier.

The model that works: agents are the lowest level of the team, and every one reports to a human. Each agent has a row with an owner, a role, a scope, and the workspaces it can see. When you hire a human you provision an agent; both show up in the same team list, both get onboarded, both get their access revoked the same way when the work is done. The org chart grows a second dimension: humans across the top, agents underneath, each tied to the human who owns it.

This is where a growing number of teams already are: two humans and four agents, or one human and a dozen. Work that does not need a person in the loop runs on the agent layer overnight, and the team arrives to visible progress and queued questions. Coordinating that layer is covered in AI agent orchestration; the day-to-day of humans and digital workers sharing tasks is in AI coworkers. Thinking of them as employees rather than tools forces the right questions: who owns this one, what may it do, who reviews it, how do we let it go.

Offboarding: revoke the key, keep the record

Every hire ends, and this is where the "agent as employee" frame proves it was more than a metaphor.

Because the AI employee had its own credential, letting it go is clean. You revoke its key. From that instant it can no longer act, and no other agent or human loses access, because nothing was shared. You can fire the agent without firing yourself.

Two things survive, and both should. The audit trail stays: everything the digital worker did remains on the record, signed and time-stamped, so months later you can still read what happened and who did it. And the accountability chain stays legible, because every action was attributed to the agent and the agent had a named owner. Contrast the shared-key world, where offboarding an automation means rotating a credential six other things depend on and hoping you did not break one. Per-agent identity makes revocation a scalpel, not a grenade. The full lifecycle is in AI teammates.

FAQ

What are AI employees?

AI employees, also called digital workers, are AI agents that operate as members of a team rather than as one person's assistant. Each has its own identity and credential, its own seat in a shared workspace, and a human owner accountable for it. The test is whether you could put it on an org chart as its own row. If it only lives inside one human's chat history, it is an assistant, not an employee.

What is the difference between an AI employee and a chatbot?

A chatbot is a conversation: you type, it replies, the exchange lives in your session. An AI employee is a principal on a team: its own credential, edits to shared surfaces its teammates can see, an audit trail on every action, and it can be onboarded, reviewed, and offboarded. The chatbot forgets you when the tab closes; the digital worker's output accumulates in a workspace that outlives any session.

How do you give an AI employee its own identity?

Create it as a distinct entity and issue it a credential, an API key or equivalent, bound to that entity rather than borrowed from a human login. Every action uses that credential, every edit is attributed to it, and permissions are scoped to the agent. The anti-pattern is a shared service account several agents use, because it destroys attribution.

How do you onboard a digital worker?

Write an onboarding doc, what the agent does, what it does not do, who owns it, what to escalate, and pin it so the agent reads it every session. Because agents have no memory between sessions unless you build it, this pinned doc is the worker's continuity: the difference between an agent that re-derives your norms every morning and one that already knows them.

Can digital workers replace human employees?

Digital workers add a layer rather than swap out the human one. They take the work that does not need human judgment in the loop, run it continuously, and pause for a person on open questions or irreversible operations. The teams getting value pair them with humans: the agent produces, the human reviews and owns the outcome. See McKinsey on the future of work for the broader picture.

How do you offboard an AI employee?

You revoke its credential. Because the AI employee had its own key rather than a shared one, revocation cuts off exactly that agent and nothing else. The audit trail stays intact, and because every action was attributed to a named owner, the accountability chain does not go dark when the worker leaves.

How to hire your first AI employee

The teams that do this well run the same sequence. Do it in order; skipping a step is the failure mode.

Write the job description first. Decide what this digital worker is for: one role, one clear outcome, and the boundary of what it should not touch. A vague hire produces vague work, human or agent.
Provision it with its own credential. Create the agent as its own entity and issue it a key bound to that entity. Not your token, not a shared service account. Everything else depends on this step.
Add it to one workspace and scope its access. Give it a real seat, but start narrow: one workspace, editor or commenter permission, not the run of the whole org. That is where you catch the patterns needing correction.
Write and pin its onboarding doc. What it does, what it does not, who owns it, what to escalate. Pin it so the agent reads it every session. Without it, the worker starts from zero each time.
Define who reviews its work. Name the human who owns the outcome, and review by reading the audit trail and workspace state, not by re-reading every draft. An AI employee with no reviewer is an unmanaged one.
Run a first-week debrief. Read the trail end to end, find the two or three places it did the wrong thing, and fold each correction back into the onboarding doc. The first week is where the working pattern is set, for a digital worker exactly as for a person.

Where Dock fits

Dock is a shared cloud workspace where humans and AI employees read and write the same state in real time. The primitives that hiring a digital worker requires, an identity per principal, a real seat, an audit trail on every action, are the primitives the workspace is built on.

You provision an AI employee the way you invite a human, and add it to a workspace the same way. Its edits show up signed by the agent, time-stamped, on the same surfaces the rest of the team writes on. It reads a pinned onboarding doc each session, pauses on irreversible operations to ask a human, and runs on whatever agent framework you prefer, because Dock is the operating layer, not the agent. When the work is done, you revoke its key and the record stays. Plans scale with your agent headcount: Free runs 3 agents, Pro at $19 a month runs 10, Scale at $49 a month runs 30. Backed by Y Combinator. See pricing for the full breakdown.

If you are running agents on real work and feeling the friction of babysitting a tool with no seat, stop treating it as a tool. Hire it.

AI employees and digital workers: hiring agents onto your team