Modern tools promise simplicity but quietly create bywork—the hidden labor of maintaining, fixing, and managing complex systems. As these tools multiply, so does work about work, leading to frustration and inefficiency. The answer isn’t fewer tools but smarter, autonomous systems that manage themselves. Complexity is inevitable, but with the right design, it doesn’t have to overwhelm us.

---

We live in a strange paradox. Technology promises to simplify our lives, reduce the workload, automate the mundane. And in some ways, it delivers. But look closer, and you’ll see another layer quietly building beneath the surface—the unspoken consequence of every new tool, every shortcut, every system upgrade: bywork.

Bywork is the hidden labor that emerges alongside your primary efforts—the maintenance, cleanup, data recovery, account migrations, oversight, and administrative debris that accumulate as a side effect of getting work done.

The more systems we stack, the more bywork creeps in. And when left unchecked, it compounds into something larger: work proliferation—the exponential growth of work about work. It’s the reason teams feel like they’re drowning in admin, even as their tool stack grows more sophisticated.

I saw this play out again just this morning, in an email from a SaaS product called StealthGPT. Their pitch? Use their service to “humanize” your AI-generated writing, so professors, managers, or detection tools won’t realize you used ChatGPT to complete your work.

The irony couldn’t be clearer. We built tools like ChatGPT to save time writing. Now we need new tools to disguise the work done by those tools. And even after that, the process isn’t done—fact-check, personalize, rework, adjust. Layers of bywork on top of what was promised as a shortcut.

It’s everywhere. Inside companies, the pattern repeats daily. One of our department heads left recently. They had recorded over 2,100 meetings using a SaaS platform. Great system—until the day they exited. Turns out, they’d registered the account under their personal email. Recovering access meant fighting through security protocols, navigating verification loops, all tied to their private phone number. Even when we finally got control of the account, one of our developers lost hours figuring out how to export those recordings.

That’s bywork. That’s work proliferation. The system solved a problem—recorded meetings—but it also planted the seeds of downstream complexity. The modern workplace is drowning in this. New platforms. New automations. AI models layered over task management tools layered over chat systems layered over reporting dashboards. Each tool brings its own data, its own permissions, its own vulnerabilities. Every artifact—documents, accounts, outputs—becomes a fragment. And fragments, without structure, generate bywork.

But here’s the uncomfortable truth: complexity itself isn’t the enemy. Complexity is inevitable. The modern world, especially at scale, is complex by design. The real failure is allowing complexity to run unmanaged.

We treat work as isolated tasks. Tools as isolated solutions. But systems don’t live in isolation. They interact, overlap, generate dependencies. And when we fail to design for those dependencies, bywork proliferates.

This is exactly why I’ve been building the Autonomic Framework, the backbone of my work at workcontrol.org. The philosophy is simple: If complexity is inevitable, autonomy must be designed into the system. Environments must behave more like biological organisms: self-monitoring, self-adjusting, resistant to fragmentation.

Imagine this:

• Systems that track their own artifacts—documents, recordings, AI outputs—with full lineage and traceability.
• Tools that carry embedded awareness of ownership, access, expiration, and downstream impacts.
• Work environments where the bywork of recovery, restructuring, and realignment happens automatically—surfaced early, contained by design.

We don’t need fewer tools. We need better-integrated tools. We don’t need to avoid complexity. We need systems resilient enough to hold complexity without drowning workers in invisible labor.

Work proliferation is a solvable problem. But only if we stop reacting to complexity as if it’s a glitch—and start governing it as if it’s the environment we operate within. That’s what the Autonomic Framework aims to achieve: autonomous work environments where tools don’t just execute tasks—they govern themselves. Bywork stays contained. Work proliferation is managed at the system level, not left to manual intervention.

It’s a frontier worth building toward. Because the alternative is what most organizations face today: a tool stack growing faster than their capacity to manage it, a hidden mountain of bywork growing quietly in the shadows, and workers wondering why the promise of simplicity always seems just out of reach.

We can do better. Complexity isn’t the enemy. Uncontrolled complexity is. And that’s a design problem—one we’re fully capable of solving.

…