The New Hires Never Sleep

Note: the original post was written in french and is available here

Tuesday, September 1st. Back-to-office day. My intern is dead.

The task was harmless - one line of code, one file. The protocol waits for a response for 300 seconds. At the 300th: nothing. By every rule we had written, the intern was dead - unreachable, silent, unreliable. The case was closed.

The file arrived at the 412th second. In the right place, correct, on time by any human standard. The work had been done. It had simply arrived after everyone had already concluded it wouldn't.

I keep this number - 412 - because it condenses everything I've learned these past weeks about working with AI agents into a single figure. The problem was never the intern. The problem was the mailbox. And the problem, I should add, was entirely our fault.

Who is the intern, and who am I?

Let's step back. I run Advanced Stack, an AI consulting firm in Paris. I specialize in answering the question everyone in the office pretends to have mastered: what do we do with AI, in what order, and why?

Behind this question lies a deeper stake: the management of the unknown. Between cost pressure and apprehension about the evolution of work, paralysis is common. Teams don't dare ask the fundamental questions, fearing their answers (or their lack of answers) will trigger austerity measures.

My role is to break this silence. I turn this collective anxiety into concrete strategy, so that the work arrives in the right place, at the right time - even if it takes 412 seconds.

As for proof, I'm working on it continuously.

Here's the part that deserves a moment's reflection: since this summer, the firm itself has been running with a team of four AI agents. I am the only human on the payroll.

This is not a stunt. It's a design decision for the company. I sell my judgment on AI, and the only way to know whether a claim is honest is to live it. My clients receive my experiences as field reports - failures included. The best field report, it turns out, is the one written about your own company.

The Horse and the Harness

If you used ChatGPT at launch, you've already been talking to an AI agent. It wasn't the revolution of work, nor an autonomous supercomputer. It was a small agent, limited, but an agent nonetheless: a system that, faced with a request, decides for itself what to look for, how to look for it, and comes back with the answer. You didn't tell it to dig through the web. You certainly didn't point it to the source.

What has changed since then isn't the beast. It's the interconnections.

The revolution underway doesn't reside in the model itself. It resides in the ability to connect that model to your existing systems: your files, your calendar, your code, your notes, your laptop.

We call the software that surrounds the model a harness.

The horse is the language model.

The harness is everything that makes the horse useful: the tools it can touch, the bit that limits its trajectory, the reins that bring it back to order.

And as with any horse, the rule is simple: the better the harness is fitted, the more powerful the animal. And the more damage it can do if the rider lets up.

AI Agent = Model + Harness.

That's the 2026 definition. The rest of the article is what happens when you put this horse to work, in a real office, with real rules.

The Era of the Intern

Before the team of 4 agents, there was the experiment. I made it into a field report, so I'll be brief: 47 hours of an autonomous agent running its own computer. One agent, a modest Linux server, and email as its only interface. I treated it like an employee you could write to. It set up its own maintenance routines, built its own memory, ran its own evaluations, and sent me a report every morning.

It also cut off my access to the server in the tenth minute - a firewall reset that severed my own connection. A new hire reprogramming the office locks before anyone handed him the key. And a good part of its evaluation data turned out to be nonsense, because of a limit I had set and never measured. Not the agent's fault. Mine.

The only lesson of G.E.A.R. that matters for everything that follows: the self-evaluation loop is the only loop that matters. If a system can't check its own health, notice when it's wrong, and repair itself without a human in the room, nothing it does on top of that is worth trusting. Every system in the current office is built on this goal.

G.E.A.R. was the v0 - one agent, learning what breaks. What runs the company now is the v1. Let me introduce the staff.

Meet the Team

TARS is the coordinator. It routes work to the right agent, schedules recurring tasks, and writes the weekly review of everything that happened. The name comes from the onboard AI in Interstellar - the one that tells you the truth even when it's awkward. That's the job description. It's also the agent you're most likely to talk to when you write me.

HAL runs the development factory. Named after the ship's computer in 2001: A Space Odyssey - but don't worry, it doesn't refuse to open the airlock. It's the only one of the four that ships anything: the website, the tools, the infrastructure. If it works, HAL built it. If it's broken, HAL is already on it.

ARIA is the creative director. Positioning, copy, brand, and market research. Last week, she came back with a number that won't leave my head: about 94% of B2B buyers now use an AI during the buying process - Forrester, State of Business Buying 2026. Before even speaking to a human, the machine has already formed an opinion about the company. I'll come back to that below.

BIC is the intern. A small local model - under 3 billion parameters, a baby compared to ChatGPT or Claude - running on purpose, to see whether a small model holds up under real work. The results so far are a study in contrasts. It writes genuinely well. It wrote a Vonnegut-style short story I didn't think a model its size could handle. In an incident-triage test, it ranked a customer data breach below a consulting deck, because the urgency of a deadline beats the severity of a risk in its judgment. And when asked who it is, it doesn't say "BIC" - it recites its model's serial number.

It's still in evaluation. It's not qualified yet. We'll see if it gets hired.

The Office

The company is already green-IT. Everything runs on a few small computers in a server rack that fits in a closet. One is a machine that fits in the palm of your hand. The other is a Mac Mini 2012 saved from recycling. The office - the notes, the task board, the messaging, the code, the memory - is self-hosted, which means the company has no front door: nothing is exposed to the street, and every connection travels on a private, encrypted corridor no outsider can cross. Only the brains are rented; the minds behind them live where the work lives.

The office has a sensible layout, because the agents needed it:

• Each system lives in its own container - think of a small office with fireproof walls. If something catches fire, the walls hold.
• A shared notes vault is the company's memory. The agents read it, write to it, and correct it. When one of them learns something, the lesson goes into the vault, where the rest of the team can find it tomorrow.
• A task board is the room's whiteboard.
• An instant messaging channel is where the team talks.

At 2 in the morning, a nightly audit runs.

It's the night watchman of the building, except it writes a note every morning: what's running, what's down, what has drifted, what it suggests fixing before the coffee.

Last week's note spotted a service dead for three days and a second service that had appeared overnight without ever being documented.

The night watchman doesn't sleep.

The Week the Team Actually Worked

Friday. A real project, not a test. Four sub-agents launched in parallel, a corpus of nearly a hundred publications to analyze, deliverables in French: author profiles, publication lists.

Thirteen minutes. From launch to verification. Eight files, delivered.

And the detail that struck me: one of the four agents counted its own deliverables, detected an inconsistency - a summary marked "unavailable" even though the abstract was clearly present - and fixed it without being asked. No human supervisor. Just an agent re-reading its work.

That was the peak of the week. Then, as in any real company, the fog rolled back in.

HAL's first call to the intern went to HAL himself. A copy-paste slip. The address pointed to its own number. The trust list rejected the call with a 401. The cable was good. The recipient was wrong.

New codified rule: When a call is rejected, re-read the number you dialed before you blame the telephone company.

The notes system learned to lie, politely. Its API accepted a parameter that doesn't exist. No error. Just a "success" response. And on disk, an empty note, with a title and nothing else. In a human office, we have a name for that: the intern who says "Yes, yes...".

New codified rule: Always verify the file's content once it's saved. Never trust the "success" status.

An automation deleted itself, twice. Its script lived in /tmp - the room the operating system wipes clean on every boot. It died on the first restart, died on the second. The restart meant to fix one problem caused two more.

If you keep your notes on a desk that's cleaned at 6 in the morning, you can't blame the cleaning crew when they vanish.

From that week, the company extracted three rules, now engraved in the way our agents work together:

• Delegation is freight transport, not a voice message. You don't wait for the reply by magic - you physically check the package.
• Verify what was written, never the "success." The API's silence is not proof of life.
• Don't delegate what's cheaper to do yourself. A line of code sent over the network and back is a net loss. Some work is for the person - or the agent - sitting next to the keyboard.

What to Take From It

Strip away the machinery, the code, and the agents. Three truths remain.

The machine has already analyzed your company before your client does.

94% of B2B buyers use AI before speaking to a salesperson. That means your positioning is no longer just read by humans: it's scanned, analyzed, and classified by algorithms.

What we sell at Advanced Stack - a clear position, an explicit difference - has become one of the criteria that matter to these machines.

You can still win on name recognition, but that monopoly collapses the moment AI detects a real difference. Being clearer than the competition is enough to stand out.

The rare thing is judgment, not execution.

The agents handle the mechanics: the routing, the building, the writing, the audit. That's their domain.

The human keeps strategic priority: what to do, in what order, and why.

That's the soul of the company. It doesn't delegate. It doesn't automate. It's what makes the difference.

The real modern skill is verifiability.

Every incident of that week was not a failure of the machine, but a failure of our discipline of verification: a mailbox that closes too early, a false "success", a reply that arrived after the deadline.

The question to stop asking: "Can AI do this?"

The question that matters: "Does my organization have the discipline to verify what the machine did?"

The Open Door

The intern's final exam is still pending. The last element of its configuration arrived this week; it's running its smoke tests. When it's qualified, one of us will have to run the interview. Probably HAL.

And I'll leave you with a thought.

These past months, companies have spent millions on AI. They bought tools, licenses, access. They asked themselves the same question: what do we do, in what order, and why?

Most bought a tool. Some bought a strategy.

Almost none hired the night watchman.

Every morning, a note arrives. What's holding. What has drifted. And if a file arrived at the 412th second in the night, it's marked.

If you'd like to see the watchman's note, send me a message.