For most of the history of knowledge work, progress required presence. You sat at your desk, you did the work, you left, it stopped. The next day you picked up where you left off. This coupling was so complete, so obvious, it didn’t need stating. Progress and presence were the same thing.
Something has changed.
The old rhythm
In the traditional model, work had a clear pulse. You arrived, you worked, you left. Progress accumulated while you were present and paused when you weren’t. Your calendar and your output were tightly coupled. This wasn’t a limitation — it was the nature of the work itself. Documents didn’t write themselves. Spreadsheets didn’t update overnight. Code didn’t write itself; bugs didn’t get fixed on their own. The work waited for you, and you could count on finding it exactly where you left it.
Over time, we added automation to support this rhythm. CI pipelines run after you push. Tests execute while you’re in meetings. Deployments propagate while you’re asleep. But notice what’s happening here: these systems are still serving your work. You write the code; the pipeline builds it. You define the tests; the system runs them. You push the change; infrastructure deploys it. The automation handles the supporting tasks — the building, testing, validating, deploying — but the generative work remains yours. Perhaps eighty percent human action, twenty percent automated support. This is evolution: the old rhythm made more efficient, but fundamentally unchanged. You are still the one doing the work.
There was something restful about this model, even as it grew more sophisticated. When you closed your laptop, the meaningful work stopped. Systems might churn through their queues, but nothing new was being created. You might wake to a failed build, but you wouldn’t wake to new features. The project waited for your return, for your decisions, for your keystrokes. Endings were still natural — they happened when you stopped producing. The boundary between working and not-working remained clear, even if the machinery ran overnight.
The new rhythm
What’s emerging now is different in kind, not just degree. AI agents don’t merely support your work — they generate it. You describe an intent, a feature, a bug, a strategy; the agent elaborates, considers, refines, designs, and codes. You review and approve; the agent moves on to the next task. The work itself is being created while you’re away, not just processed or validated.
This is not evolution. It’s an inversion. Where automation previously handled perhaps twenty percent of the work while you contributed eighty, the ratio is flipping. In some contexts today, it’s already closer to eighty percent AI-generated, twenty percent human supervision. The trajectory suggests this will continue — toward ninety-nine percent, then ninety-nine point nine, and beyond. These numbers are illustrative, not precise, but the order of magnitude matters. We’re not talking about incremental efficiency gains. We’re talking about a fundamental shift in who — or what — is doing the work.
If you work in software, you may already feel this. You wake to pull requests you didn’t write. Features have been implemented overnight, awaiting your review. Bugs have been fixed while you slept. Refactoring has been completed across the codebase. The repository shows a history of meaningful activity — not just builds passing, but actual work done. Decisions made, code committed, progress achieved — all in your absence.
The qualitative shift is profound. You move from operator to supervisor. You still create, but at broader brush strokes and higher layers of abstraction — the agent handles fine-grained implementation while you shape the larger picture. Presence becomes about judgment, not production. Your value shifts from keystrokes to decisions. The boundary of “what requires a human” is moving, and it’s moving rapidly.
What this changes
When work continues without you, several things shift in ways that are easy to overlook until you notice them accumulating.
The morning changes. You don’t start fresh — you start by catching up. What happened overnight? What succeeded, what failed? What’s waiting for a decision? What needs correction? The first task is often triage, not creation. You arrive not at a blank slate but at an inbox of outcomes. The skill becomes quickly assessing work you didn’t do, making judgments about code you didn’t write, deciding what to approve and what to redirect. This is a different kind of morning than sitting down to a blank editor and beginning to type.
Closure becomes elusive. There’s no natural stopping point when work continues without you. “Done for the day” becomes a choice you impose, not a state the work reaches. You have to decide to stop, knowing the work won’t stop with you. The old rhythm had natural endings — they happened when you stopped. This rhythm has none. Discipline shifts from “finishing what’s in front of you” to “deciding when to disengage.” Walking away requires intention it didn’t before. You’re not completing something; you’re interrupting something that will continue without you.
Attention fragments. If work can progress at any time, notifications can arrive at any time. The boundary between working and not-working blurs unless you actively maintain it. Your phone buzzes with a completed task at dinner. An agent finishes a feature while you’re watching a film. The awareness that something might need you never fully switches off. You’re always potentially on call for a review, a decision, an approval. The work doesn’t respect your calendar because it doesn’t need your calendar.
The feeling changes. There’s something different about knowing that agents are working, progress is being made, code is being written — even when you’re not watching. It’s not quite anxiety. It’s not quite excitement. It’s a low hum of ongoing-ness, a background awareness that the system is alive and moving even in your absence. This hum didn’t exist before; now it’s constant. We’re each learning to live with it, to tune it out when needed, to tune back in when required.
The relationship to your own work changes. Some of “your” work isn’t yours anymore — not in the sense of keystrokes, anyway. You’re responsible for output you didn’t produce. The code carries your name, but not your fingerprints. Reviewing becomes more important than writing. Quality control becomes your primary contribution. You’re accountable for work you directed but didn’t do, and this changes what ownership means.
What you provide changes. When you’re not producing the work directly, what you provide becomes about shaping it. Constraints become essential — what should the agent not do? Guardrails become essential — how do you keep it on track? Vision becomes essential — what are we actually building, and why? Direction becomes essential — what matters most right now? Without these, agents generate noise, not progress. Your value shifts from execution to curation and judgment. The less you do directly, the more what you decide matters.
The trade-off
This isn’t purely good or bad. It’s a trade-off, and like most trade-offs, it’s worth being clear-eyed about both sides.
On one side: more gets done. The leverage is real. Parallelism at scale — many agents, many tasks, all progressing simultaneously. Work that took days can complete in hours. You can start something, step away, and return to find it further along than you left it. Bottlenecks shift from “waiting for humans to do” to “waiting for humans to decide.” Individual output capacity is multiplied dramatically. The productivity gains aren’t marginal; they’re transformational.
The cost of experimentation shifts dramatically too. When agents do the implementation, prototyping doesn’t have to mean sketches and wireframes — it can mean fully working systems. You can try an approach, see it built, evaluate whether it works, and pivot if it doesn’t. The cost of being wrong drops. The cost of exploring alternatives drops. What once required careful upfront planning can now be discovered through rapid iteration. This changes how decisions get made.
On the other side: the rhythm of work changes in ways we’re still learning to navigate. Rest requires intention it didn’t before. Boundaries require active maintenance. The skill of “putting work down” becomes something you have to cultivate, not something that happens automatically when you close your laptop. The old natural endings have to be replaced with deliberate ones. The mental separation between work and life erodes unless you consciously maintain it. It’s harder to feel “done” when the work is never done.
And some things change in unexpected ways. Learning and skill development — if you’re not doing the work, are you building the skills? Debugging — how do you debug code you didn’t write? Ownership and accountability — whose bug is it when an agent introduced it? Onboarding — how do you learn a codebase that agents maintain? Career progression — what does “senior” mean when agents do the implementation? These questions don’t have settled answers yet.
What this doesn’t mean
This isn’t an argument that presence doesn’t matter. Focused, uninterrupted thinking still requires engagement. Creative leaps still require presence. Complex collaboration still requires synchronous attention. Judgment, taste, direction — these still require you. The work that continues without you is a particular kind of work. The work that requires you is different, and no less important.
Not all work shifts at the same rate. Routine implementation is moving fast. Novel architecture, slower. Cross-functional coordination still requires humans. Anything requiring deep organisational context remains human for now. The frontier is uneven, and will likely stay that way.
This isn’t a loss of agency — but it is a change in what agency means. You still direct; you just don’t execute. Your decisions still matter — arguably more than before. But the nature of your contribution changes fundamentally. The shift isn’t from presence to absence. It’s from exclusive presence to mixed presence — periods of focused engagement punctuated by periods of supervision and review. From continuous doing to intermittent oversight.
The work continues without you. That doesn’t mean the work doesn’t need you.
Where this leaves us
Progress is no longer tied to presence. For most of the history of knowledge work, that sentence wouldn’t have made sense. Now it’s simply true — not for supporting tasks, but for the work itself. Features written, bugs fixed, decisions made, all while you slept.
This changes more than productivity. It changes what your presence is for. It changes what mornings feel like, what endings require, what rest means. It changes the relationship between you and the work that carries your name.
The rhythms haven’t settled. The boundaries are being drawn and redrawn. The low hum of ongoing-ness is new, and we’re each finding our own way to live with it.
The work no longer waits for you. What that means — we’re still learning.