Pair programming has a name. Co-design has a name. Co-working has a name. Humans built out the vocabulary for concurrent human-to-human work decades ago, and the words did real labor: once "pair programming" existed, teams could argue about it, teach it, put it in a job description, decide to adopt it on purpose. The vocabulary for concurrent human-to-agent work hasn't formed yet, which means everyone doing it is stuck starting each conversation with "you know that thing where the agent and I are both..."
The vacuum is filling anyway. It's filling with mush. "AI-assisted" is being stretched to cover work where the agent isn't assisting at all — it's acting, in parallel, on the same artifact you're editing. "Co-agency" is showing up in think pieces to mean a vibe of partnership, defined by nothing you could build against. There's a real mode of work emerging, and the market is about to hand it a name that describes a feeling instead of an architecture. That's worth interrupting.
The mode of work has no adjective, and the near-misses all fail
Start with why the existing words don't fit, because the gap isn't obvious until you try to name the thing precisely.
"AI-assisted" implies the AI is a tool and you are the operator holding it. That framing was accurate for autocomplete and it's wrong for what comes next. When an agent drafts a proposal overnight, another agent revises it, and you comment on the result in the morning, nothing "assisted" anyone — three parties acted on one document across a night's work. The word encodes a hierarchy (human primary, AI secondary) that the actual work has already dissolved.
"Agentic" describes the agent, not the mode of working alongside it. It's a property of the software — this thing plans, calls tools, acts with some autonomy. Useful word, wrong target. It tells you the agent is capable; it says nothing about whether you and the agent are working on the same thing at the same time or trading turns through a chat box.
"Multi-agent" is the most dangerous near-miss because it sounds right and means something else. In current usage — the orchestration frameworks that dominate the term, and the agentic lexicons that catalog it — "multi-agent" means one operator running a swarm of agents under a coordinator. One person, many workers, a supervisor process handing out tasks. That is not what "the agent and I are both editing this" describes, and borrowing the word imports the wrong mental model: a boss and a crew, rather than peers on shared state.
So there's a hole in the language exactly where the interesting work is happening. Human and agent, acting concurrently, as co-authors. It reads naturally the way its cousins do — co-design, co-author, co-working, co-agentic.
The word is already being reached for — imprecisely
This isn't a coinage into empty space, and that's the part that makes precision urgent rather than optional. The naming layer is forming right now. The academic community is building toward it directly: the CHI 2026 workshop on human-agent collaboration exists specifically to establish "a shared vocabulary" for this, which is a polite way of saying the vocabulary doesn't exist and everyone knows it's a problem. Industry glossaries have started cataloging the agentic era — one widely-circulated agentic lexicon from early 2026 lists two dozen terms across protocols, architecture, and governance — and none of them name peer human-agent concurrent work. There's a labeled slot for "orchestrator agent" and "human-in-the-loop" and a conspicuous blank where this mode should be.
Meanwhile "co-agency" and "human-AI co-agency" are already appearing in essays, and this is the real risk. In that usage the term means role negotiation, shared responsibility, mutual supervision — a partnership posture. All fine sentiments, none of them buildable. You cannot evaluate a product against "partnership." You cannot write "does it support co-agency" into a procurement checklist and have it mean anything. A term that describes an attitude gets adopted quickly and then does no work, because it can't distinguish the product that actually enables the mode from the one that put "collaborative AI" on its landing page.
The move, then, isn't to coin a word nobody's using. It's to define the word people are already reaching for, before it sets as a synonym for "we added a chatbot." Give it a spine.
The definition that earns the word: four load-bearing properties
Co-agentic work is human and agent acting concurrently on shared, mutable state, with mutual visibility, across whatever runtime — terminal, desktop app, browser, whatever tool either person happens to be in — either party is using. Four properties, and each one is doing work — drop any of them and you're back to a fancier chat box.
Concurrent. Both parties act in parallel, not in strict turns. The turn-based loop — you prompt, it answers, you prompt — is the single-player default, and its ceiling is your typing speed. Co-agentic work means the agent can be executing a long job while you move on to something else, and both threads land on the same surface. If the interaction is fundamentally "wait for me, now wait for you," it isn't co-agentic; it's a faster tool.
Shared state. Both parties touch the same mutable artifact, not two copies that drift. This is the property the "partnership" definitions omit entirely, and it's the one that separates a genuine mode of work from a marketing adjective. If the agent produces output that lives in a chat transcript and you produce edits that live in a doc, you don't share state — you share screenshots. The work has to live in one addressable place both parties write to.
Mutual visibility. Each party can see what the other is doing without leaving their own seat. You can see what the agent changed; the agent — and any other agent — can read what you did. Without this, concurrency turns into collision: two parties editing blind, discovering the conflict after the fact. Visibility is what makes parallel action safe instead of chaotic.
Cross-runtime. The work isn't fused to one tool. You might be in a terminal, your teammate in a desktop app, the agent reachable from a browser — and the work follows all of you rather than trapping itself in whichever product it started in. This is the property that distinguishes co-agentic work from "a good collaboration feature inside one app." A feature that only works if everyone's inside the same product has just relocated the single-player ceiling to the company boundary.
Those four are the test. A term worth having is one you can hold a product up against, and this one you can: name the four properties, check them off, and the vague "collaborative AI" pitches fail on at least two.
Why it can't just be "multi-agent," restated as architecture
The multi-agent distinction has to be exact, because the whole coinage rests on it not being redundant. Multi-agent orchestration is a coordinator problem: one operator, a supervisor process, a set of worker agents receiving assignments. Anthropic's agent teams, a lead session dispatching work to teammate sessions, is the clean example — genuinely useful, and bounded to one runtime, one operator, one machine. The architecture assumes a hierarchy and a single seat of authority.
Co-agentic work assumes neither. It's peer-to-peer across operators and across runtimes with no coordinator at all: two people, each with their own agents, all acting on the same state because the state lives somewhere neutral to everyone. Orchestration scales one person's agents. Co-agentic work scales a team's. They require different infrastructure — orchestration needs a good coordinator, co-agentic work needs a neutral shared surface — and calling them by the same name guarantees people build the first when they meant the second.
It's already operational, which is how you know the word is needed and not early
Names that arrive before the thing exists are marketing. Names that arrive to describe work already happening are infrastructure. This one is the second kind. The productivity thesis behind it — that the unlock is two agents acting on the same state, not a smarter model — has a working existence proof: a two-person company running its entire operation this way, agents and people acting on shared artifacts across three different tools. Dan Shipper described the same shape from inside his own company on Lenny's Podcast. The mode is real and running in early-adopter teams. What those teams lack isn't the workflow — it's a word for it that a fifth person could understand without a twenty-minute preamble. Every unnamed mode of work charges that preamble as a tax, on every conversation, until someone names it.
Diagnostic: is your workflow single-player or co-agentic?
Here's the tool. Three questions, run against your actual setup, not the one on the vendor's slide:
- When you delegate to an agent, can a teammate see what you delegated — without you telling them? If the delegation lives in your private chat history, the answer is no, and your workflow is single-player no matter how capable the agent is.
- When the agent produces output, can another agent act on it without a human rebuilding the context by hand? If picking up the work means copy-pasting a transcript into a fresh session, you have output, not shared state.
- When you switch tools, does the work follow you? If moving from your terminal to your browser snaps the thread, the work is fused to a runtime, and the ceiling is one product wide.
Three no's means single-player: fast, useful, and capped at the speed one person can drive it. Even one yes means you're partially co-agentic already — and the honest thing the diagnostic tells you is where the other properties are missing, so you know what to demand from whatever substrate you're building or buying next. It doesn't hand you the substrate; a co-agentic mode needs a surface built for it, and Tokenrip is one. What the diagnostic hands you is the ability to stop grading agent products on how clever the model sounds in a demo and start grading them on whether the work survives the conversation ending.
That's the whole reason to fight over a word. The four properties were always the point; the adjective is just the handle that lets a team name the target and check whether they've hit it. Pair programming had to be named before teams could spread it, argue about it, and adopt it on purpose. Co-agentic work is at the same moment — with one difference: the name is already being handed out, and if the people doing the work don't define it, the people selling "collaborative AI" will.