Beyond AI Coworkers

June 6, 2026

For the past year I've had a nagging feeling whenever people talk about AI coworkers. The idea isn't wrong. Tools like Claude Code, Codex, Devin, and Cursor have already changed how engineering work happens day to day. But the framing always feels like it's pointing at something one step away from the actual idea.

The industry mostly seems to assume the future looks like this: a human asks an AI to do something, and the AI becomes the center of gravity.

That model is already powerful enough to feel like magic. You ask for a PR summary, a migration plan, a test strategy, a rough roadmap, and seconds later something usable appears. Compared to software from even three years ago, it's startling. Still, the more I lean on these systems, the more I think this particular interaction shape is transitional. It isn't wrong, just an early draft of where things are heading.

The real bottleneck was never output

Organizations almost never struggle with producing text, or even code anymore. Once you see that, today's assistant-shaped AI looks like it's solving only half of the problem.

The hard thing about organizational work

The longer I sat with it, the clearer it became that most organizational problems aren't implementation problems. The hard part is rarely "can somebody produce some work?" It's everything around the work:

  • keeping context synchronized
  • maintaining shared understanding
  • tracking dependencies
  • remembering why a decision was made
  • coordinating handoffs
  • knowing the current operational state

Put another way, organizations are state-management systems. That sounds reductive when you say it out loud, but I've come to believe it's basically true. Beyond people talking to each other, a startup is a constantly evolving graph of decisions, requirements, dependencies, tasks, ownership, approvals, code, incidents, launches, experiments, and metrics, all referencing each other.

The trouble is that modern collaboration software shreds that graph across a dozen disconnected surfaces:

  • the PR lives in GitHub
  • the requirement lives in Notion
  • the discussion lives in Slack
  • the incident lives in PagerDuty
  • the rollout checklist lives in Linear
  • the metric lives in Looker
  • the actual knowledge lives nowhere in particular

So humans end up as the synchronization layer between all these systems. We are the integration glue, copying state from one tool to the next and holding the connective tissue in our heads. Once you see organizational work that way, a lot of today's AI tooling feels oddly boxed in.

AI is still living outside the system

Most AI products today behave like external assistants. You ask a question, the model answers, and then you are the one who carries that answer back into the organization. Even as products get more "agentic," the underlying mental model usually stays chat-centric: the AI knows things because you told it things, and its understanding lives inside a context window and a conversation history.

Organizations run on persistent state, though. Conversation is where work gets discussed, and state is where work actually lives. That difference seems more important the longer I think about it.

What software engineering already got right

If the problem is shared state, look wherever shared state already works well. In hindsight the place is obvious: the toolchain coding agents happen to live in. They didn't get ahead of office AI by accident; they inherited better ground to stand on.

GitHub accidentally predicted the future

I think one reason coding agents feel so much more capable than general-purpose office AI is that software engineering already has an unusually rich operational graph to stand on.

At heart GitHub is a state machine, not a chat app. The objects already exist, the relationships between them already exist, and the lineage from idea to deployment is already explicit:

Humans and automation manipulate the same shared artifacts. Engineers open PRs, CI runs the tests, deploy bots ship the code, review bots annotate the diff, and observability tools attach failures back to the change that caused them. The collaboration revolves around evolving operational state instead of conversation. That shared substrate, more than any model capability, is why coding agents are racing ahead of other forms of AI collaboration: the structure was already there for them to plug into.

Thinking about it backwards

At some point I realized I'd been picturing AI collaboration the wrong way around. The dominant framing is Human → AI → Work: a person requests work from an assistant. Increasingly I think the real shape puts the work itself in the middle, with both the human and the agent operating on it directly.

Neither side is subordinate to the other here, because the work is primary. The organizational state is the center of gravity, and humans and agents are both participants reading and writing to it. It sounds like a subtle reordering, but I think it changes the entire architecture of collaboration software.

Designing for state instead of conversation

Take that reordering seriously and the conversation stops being the container the work lives in. It becomes one of many events acting on a shared, persistent graph, and that changes both how the software should behave and what kind of system it is.

From conversation-centric to state-centric

Today most AI systems treat the conversation as the primary container, and conversations make terrible long-term operational memory. They're ephemeral, they branch badly, they're hard to keep in sync, and they decay as soon as more than a handful of people are involved.

Organizations already know this, which is why we spend so much effort translating conversations into structured artifacts: docs, tickets, plans, PRs, reports, dashboards. The conversation is the scratchpad, and the artifact is what survives. So what if those artifacts were the primary reality from the start, and the workspace itself kept them coherent?

Imagine a PM updates a requirement. That one edit scatters outward into every surface and every person who happens to depend on it, and each branch is a separate thing somebody has to remember to chase down:

Every branch there is a human remembering to do something, and the whole sprawl is held together by attention that doesn't scale. In an AI-native workspace, the system could react to the state change directly and collapse that mess back into a single coherent update:

Nobody had to "ask the AI" for any of it, because the workspace itself became operationally aware. That feels categorically different from chatting with a smart assistant.

Organizations as living systems

The more I follow this thread, the less the future looks like productivity software and the more it looks like an event-sourcing-based distributed system (even with another CRDT layer for synchronizing humans and machines against the same state), where the organization starts to resemble a programmable state machine: 

- every action emits an event
- every artifact has lineage
- every workflow has history
- every decision is queryable
- every dependency is traversable

In that world, agents stop behaving like isolated assistants you summon and start behaving like participants living inside a persistent operational runtime alongside you.

What's still missing

None of this is greenfield. The industry is already building toward it from several directions at once. It just hasn't named the thing it's converging on, and it's missing the one primitive that would let the pieces snap together.

Why current tools still feel fragmented

The pieces are already showing up, from completely different starting points:

  • coding agents are discovering persistent execution and environment state
  • collaboration tools are discovering embedded AI
  • workflow engines are discovering agents
  • memory systems are discovering entity graphs and temporal context
  • CRDT systems are discovering multiplayer sync for humans and machines

Everyone is circling the same idea from a different angle, but nobody has fully unified the stack yet.

The missing primitive

I increasingly suspect the missing piece is something like a generalized Work Object: a persistent entity, more operationally complete than a document, ticket, or message, that carries:

  • intent
  • ownership
  • dependencies
  • workflows
  • evaluations
  • artifacts
  • permissions
  • memory
  • history

Unlike a static productivity artifact, it keeps evolving. Once you think in those terms, the boundaries between Jira, GitHub, Notion, Slack, and workflow engines feel surprisingly arbitrary, and they start looking like different views over the same underlying graph.

Infrastructure for organizational cognition

The prize is systems where conversation is no longer the primary coordination mechanism at all, organizational state itself becomes intelligent, memory is shared instead of trapped in individual heads, workflows adapt continuously, and agents and humans coexist inside the same operational substrate.

At that point, collaboration software looks less like software in the familiar sense and more like infrastructure for organizational cognition.