The Brain Server: Why Are We Still Working for Our Software?

It's nine in the morning. You've barely sat down when a client emails: could we move delivery from next Wednesday to this Friday?

A very polite request. There's even a smiley face at the end.

You check the calendar. Today is Thursday.

So you open the project tracker to check progress. Then the document to see what's unfinished. Then the team chat to ask whether the designer has time. Then another spreadsheet to find out what else an early delivery would collide with.

Ten minutes later, you're moving fluently between six windows.

Every application is working beautifully. Clean layouts, quick responses, not an error in sight. You're the only thing overheating.

You pull the information together and send it to the project lead. “Got it,” they reply. “Keep an eye on it.”

The task has now been saved to your brain.

At lunch, it will pop up again just as you take your first bite.

Where the software doesn't connect, there's a person

Most workplace software knows its job.

The inbox receives messages. The spreadsheet stores numbers. The calendar sends reminders. The project tracker makes “In progress” a reassuring shade of blue.

As for how soon the client's “ASAP” actually means, why the spreadsheet disagrees with the email, or who clicked “Got it” without starting anything—a person has to work that out.

And then remember it.

They remember which information is out of date, which sentence was only politeness, which task needs a nudge, and which colleague disappears on Friday afternoons. They turn a message in one application into an action in another, then bring the result back.

Where the software doesn't connect, there's a person.

Let's give this job a name: the brain server.

Carbon-based architecture. Coffee-powered. Handles ambiguous language. Most of the context that never made it into a database is cached in there.

Some limitations: requires sleep, goes offline on vacation, occasionally stares at an open window with no memory of why it was opened.

The company pays a monthly subscription.

The employment contract usually calls it something more respectable: operations, project manager, customer success. At a startup, “wears many hats.”

Then the workflow hears, “This one's a little different”

This sounds like a software integration problem.

Connect the APIs, sync the data, add a few rules. That really does save a lot of copying and pasting. Predictable processes have been running themselves for years: receive a form, create a record, notify the owner.

The trouble starts when the workflow begins speaking human.

“This one's a little different.”

“Hold off on sending that until I've checked.”

“Same as last time, but with the new pricing.”

The real world is far more enthusiastic about exceptions than a flowchart can accommodate.

So the person sits back down in the middle. They work out what the message means, find “last time,” decide which price is the new one, and figure out what happens next.

We've spent years giving software more capabilities. Meanwhile, people have learned to use more software.

Someone who can navigate a dozen systems is often considered very capable. They are. It's just that a good deal of that capability goes into keeping the systems on speaking terms.

Like the one person at a large family gathering who has to relay everyone's messages.

How much should an AI agent take off our hands?

This is where agents become interesting.

Say I ask, “Find out whether we can deliver this project by Friday.”

The agent should find the relevant emails, check progress, look at the unfinished work, and come back with the conflicts and possible options. If something important is missing, it should return with a specific question.

For example:

“Design still has two graphics to finish. Delivering early means pushing another task back. Which one takes priority?”

Now there's a meaningful decision for a person to make.

If the agent reports back every time it opens a page, asks permission to continue after finding each file, and finally dumps the contents of six applications in your lap, you still have plenty to do.

You've acquired a colleague who calls you “boss.”

And types extremely fast.

One plain question tells you quite a lot about how helpful an agent is: once you've handed over a task, how much of it do you still have to carry around in your head?

Can you close the window and get on with something else? Can it handle ordinary hiccups? When it comes back, can it explain what it checked, where it's stuck, and what it needs you to decide?

Clicks are easy to count. The number of unresolved things occupying someone's mind rarely makes it into a product's performance report.

That part is often more exhausting.

Which interactions are worth keeping for ourselves?

Should we hand all our software over to AI, then?

It helps to ask why we opened it in the first place.

Sometimes, we just need something done. Check stock, reconcile accounts, rename files, enter the same details into several systems. These aren't usually experiences we treasure. It's hard to imagine someone watching the sunset in retirement and saying, “What I wouldn't give to fill out that expense form one more time.”

Sometimes, doing the thing is the point.

A painter may happily spend an afternoon adjusting colors. Someone shopping for clothes may enjoy wandering without a plan. A player may not want an agent to finish a game and send over a victory summary.

The same interface can serve very different wishes.

So graphical interfaces still have a place. We need to see, compare, explore—and reach in to change something when an idea occurs to us.

What can change is how much of the process we choose to take part in.

For some tasks, we only want the result. For others, we want to set the direction. And sometimes, we want to do the whole thing ourselves.

Software should leave room for all of those choices.

Who gets the attention we save?

At this point, the brain server might breathe a little easier.

Finally. Something can take over all that fiddly coordination.

A moment later, another thought arrives: hang on. That's most of what I do all day.

This thought doesn't fit comfortably into a product launch. It makes the hopeful story go quiet for a moment.

Work gives us more than a paycheck. It gives us a particular sense of being needed: someone asks, and I know the answer. Something gets stuck, and I get it moving. Today was exhausting, but that part got done because of me.

As execution becomes easier, those familiar ways of proving our worth will change too.

We can't hand everyone a “decision-maker” badge and announce that they've been promoted. Spending all day watching agent output and clicking Approve may not feel much better than the old job.

A product that takes agents seriously needs to care about this.

Does the attention saved actually go back to the person using it? Can they understand what's happening, change direction, and take over the parts they care about? Or does their schedule simply fill with more tasks because the dashboard says they're more productive now?

These are questions for product design, and for organizations deciding how work gets done. A smarter model won't make those decisions for us.

After you hand something over

While building Junior, I want to keep coming back to that simple question:

Once a task is handed over, how much of it does a person still have to keep in mind?

Who notices when the client's requirements change? Who gathers the information scattered across systems? Who follows up when execution stalls? When should an important decision come back to a person?

If all of this still depends on the user remembering, there's a brain server hidden inside that beautiful new system.

It's six in the evening. You're getting ready to leave.

Out of habit, you open the windows one by one for a final check. Team chat, email, project progress, the person who promised an answer today.

Halfway across the screen, your mouse stops.

That task has already been handed over. The checks are done. The follow-up is happening. When there's a decision for you to make, you'll know.

You close your laptop.

The elevator arrives.