Old-School AI, Modern AI

Picture an internal escalation channel. An operations team drops incoming issues into it in a semi-structured template:

Two AI assistants live in that channel. Both were built in good faith by people trying to solve the same problem, and neither one is fully autonomous. What separates them is which half of the job each one automates.

• The Old-School AI is a purpose-built auto-investigator. It responds to every new post on its own, runs its fixed investigation sequence (pull the logs, guess the cause, draft a fix), and publishes what it finds. Its autonomy sits in publishing. Everything consequential after that still lands on a person: checking whether the finding holds, deciding what to do about it, and doing it.
• The Modern AI also acts without being asked, but on the other half of the job. It watches the same queue, investigates before anyone asks it to, and surfaces to a human at exactly one point: the moment something has to be chosen. There it posts what happened and what the options are. A person picks one, and the model does the legwork from there, with the result going out under that person's name. Its autonomy sits in the finishing. What the human contributes is judgement and accountability, and that takes minutes. Everything around those minutes is already done.

One thing to settle before we go on. Old-school here is not about the model. Both run on the same LLM, released in the same year, called through the same API. What is old-school is the way they were put together.

If one of them were a rule-based chatbot from 2019 there would be nothing to say. Both are current AI. One of them was just assembled with the habits of two years ago.

The irritating part is that in the channel it is the Old-School AI that looks industrious. Always acting, always posting. But the work stops there. Every post it makes leaves a human job behind it: verify, decide, do. The Modern AI posts about as often, and on some mornings more. The difference is that its posts take work off people's desks instead of adding to them.

Neither is a fully autonomous agent, and neither should be yet. Trust in a system like this is earned in stages: a team hands over a larger share of the work only after the system proves it can carry the share it already has. Both are pitched at the stage every system passes through on the way to autonomy: real work done by the machine, the decision still held by a person. What separates them is the four decisions made around the model while they are there. The next section puts the two designs side by side, and the four after it take those decisions one at a time.

From the outside the two are identical. A chat box, a person typing, a bot replying. That is what makes them hard to compare, and what leads most people to shrug and say they are both AI, so they are much of a muchness.

The easiest way to see the gap is to measure both against a person who does this job well. A good one does not answer straight away. They read the conversation, form a hunch, check the data case by case, throw out the hunches that do not hold, and only then conclude. The Modern AI goes through the same steps. The Old-School AI jumps from a matched keyword to a filled template.

So the left column below is not a feature list. It is what a capable person does before they open their mouth. The four rows marked below carry most of the weight, and the four sections after this one take them in turn.

One thing worth stating flatly, because it is the assumption that most often turns out wrong: putting an LLM in does not raise quality by itself. Wired badly, it lowers quality past zero.

The Old-School AI was not merely less useful. It manufactured work that did not exist before: tickets someone had to close, owners assigned wrongly and then corrected, follow-ups to undo its own actions. The expensive part is the trust. After a few reports that turn out to be empty, people stop reading the reports. Including the ones that happened to be right.

That team would have been better off never installing it.

The Old-School AI starts on a keyword match. Any post containing its name, and on bad days any post at all, kicks off the same fixed sequence, beginning with the same opening line:

An identical duplicate of that message lands a few seconds later. Then, minutes after that, a full root-cause analysis of whatever it decided the message was about.

The clearest example came when someone in the channel was not reporting an incident at all. They were complaining about the bot: can someone kick or kill this assistant, it's misfiring. That sentence contained its name, so the sequence ran. The Old-School AI:

1. Posted its investigating acknowledgement.
2. Ran a full investigation.
3. Produced a formal explanation that “based on the thread, this is not an incident report but an internal request to disable the assistant, so there is no root cause to investigate.”
4. Opened a fresh ticket about the request to turn itself off, complete with a ticket ID and an assigned owner.

Steps 3 and 4 contradict each other. In step 3 it understood perfectly well that the request was to switch it off. In step 4 it treated that request as a new piece of work and assigned it to a person anyway. Nothing in it was weighing those two against each other. A word matched, so the sequence ran to the end.

A person would never do that. They know which messages are not their job.

The engineer's reply in that thread was one word: removed. The bot was out of the channel the same day. I do not blame the engineer.

So what does the Modern AI do when the same sentence arrives? For that sentence, nothing. Words are not its trigger, so there is no acknowledgement, no investigation and no ticket. But the story was over before the complaint got written. The complaint said the bot was misfiring, and the Modern AI watches the misfires themselves rather than what people write about them. If something really is failing repeatedly, it has already posted about it before anyone gets round to complaining.

Medicine has known this failure for decades under the name alarm fatigue: monitors that fire on thresholds rather than on events produce alerts that are mostly not actionable, clinicians stop reacting to them, and the whole thing is now tracked as a patient-safety hazard.^[5] Security operations research documents the same effect: analysts in corporate security operations centres miss real intrusions when the genuine alert is buried among thousands of routine ones.^[6] The mechanism transfers straight into a chat channel. When the trigger cannot tell an event from a non-event, neither can the reader, so they stop trusting any of it and eventually stop reading the assistant at all.

There's a productivity cost stacked on top of the attention cost. Gloria Mark's 2008 study of interrupted work found that interruptions, including ones relevant to the task at hand that workers describe as beneficial, impose a measurable tax in stress, frustration and perceived workload, and that people compensate by working faster under more pressure.^[7] A trigger that fires on non-events charges that tax to every colleague in the channel and returns nothing for it.

The Modern AI is not started by being addressed at all. It is started by the situation changing: an error rate moving, a queue filling, a customer request failing in a way it has not failed before. It can post several times in a morning, and often does.

Later that week, an operator asked the Old-School AI a question inside a thread with fourteen prior messages: what's the conclusion here, is this expected behavior?

The thread it was replying inside contained the conclusion. Verbatim. Two messages above.

A person asked that question scrolls up.

A different colleague tried again in a separate thread: TL;DR of this thread please.

Agent-evaluation work makes the point concrete. Letta, a company that runs AI agents in production at scale, attributes roughly 90% of the agent failures it sees to context problems, meaning the agent was never shown what it needed, rather than to gaps in model capability.^[8][9] One production write-up puts it this way: the context window, which is the short-term memory a model holds during one conversation, is a whiteboard rather than a filing cabinet. It gets wiped between conversations, and anything not written down again is gone. That is why the assistant greeted a fourteen-message thread as the start of the chat.^[10]

Ask the Modern AI the same question and the answer comes back straight away, because it read those fourteen messages as they were written. What it adds is not a summary of the thread, which everyone in the thread already has. It adds the thing that is not in the thread: whether the same pattern is showing up anywhere else, and what changed just before it started.

The Old-School AI's output is formatted like it came out of a mature diagnostic system. Bold headers, a TL;DR section, evidence blocks, “root cause (plain language),” a proposed fix, even the name of the repository to patch. Impressive at a glance.

Read to the bottom of one and the actual signal is this:

The pipeline had returned nothing usable, and the four hundred words above that line were published anyway.

Another reply ended with its own confidence self-report:

“No tools used, answered from memory” means it looked at nothing. No logs, no data, no system state. The whole answer was pattern-matched from training, and it was dressed exactly like the answers built on evidence.

This is a calibration finding rather than a matter of taste. Xiong et al. showed across GPT-4, LLaMA-2 Chat and others that models asked to verbalise their own confidence are systematically overconfident, potentially imitating the human habit of sounding certain.^[11] A 2024 survey of confidence estimation in LLMs reaches the same conclusion: absent deliberate calibration, stated certainty and actual correctness diverge sharply.^[12]

The damage shows up on the human side as selective scepticism. A qualitative trust study with 192 participants found that people who repeatedly meet authoritative-looking hallucinations do not lose faith across the board. They stop trusting the AI in exactly the situations where the stakes are highest.^[13] The good answers get discounted along with the bad ones, and nobody files a complaint about it.

Given the same question with the same thin evidence, the Modern AI sends one line: what it does not have, and what it would need to answer properly. When the evidence is complete the answer is long. The length tracks how much it actually knows, which means the shape of the message tells you how far to trust it before you have read a word of it.

This is the part worth copying, and it is where the fourth decision shows up in practice. Read the three messages below and look for the gap between them and something a senior engineer would write. The gap is thin. Below are three shapes of message the Modern AI produced in the same channel, written by AI and sent out under a human's name. None of them depend on a stronger model. They depend on the model already holding the context when the moment arrived, on it presenting a decision rather than a status update, and on a person owning that decision and the name at the bottom.

Background for this one: the company also runs a customer-facing assistant that handles order requests, including cancellations. It is neither of our two.

The team was about to start getting complaints. Before the first one landed, the Modern AI had already noticed something that should not appear at all, the warehouse refusing cancellation requests, a dozen in one morning where a normal morning has none. It traced the cause and put this in front of the person who owns the channel. It went out word for word:

Why this is the shape of replacing human work:

• Proactive. Diagnosed before the report was filed.
• Names the actual mechanism, in words an engineer can act on and an account manager can still follow.
• Separates what's working from what's broken, which prevents overreaction.
• Two audiences in one message: a paragraph the operations team can send to those 14 customers unchanged, and a paragraph for whoever fixes the code.
• Commits to a follow-up. “The fix goes live today, and I will confirm in this thread” treats this as an owned task rather than a Q&A.

Overnight, a code change the engineering team put live quietly stopped refunds from going out. The support team's first theory that morning was a spike in refund requests from customers. The Modern AI's draft to them, in full:

Why this works where the Old-School AI would fail:

• Owns the blame in plain language, in the first line. No hedging, no “the system experienced an anomaly.”
• Numbers instead of adjectives everywhere they exist. 320, not “a large batch.” 07:00, not “earlier.”
• Organised around what the reader has to do: here is what lands in the next hour, here is what those customers will ask, here is what we are fixing. Not a chronological data dump.
• Names the second-order miss. The signal was there and was never turned into an alarm. That's what a senior engineer flags, and most AI output stops at the primary bug.
• Ends with a real apology, not “we apologise for any inconvenience.”

The company's payment provider had a brief outage. The Modern AI drafted the full post-incident report within hours. Reports like this normally arrive days later, once someone senior has cleared the time to reconstruct the timeline. I have more often been on the side that never cleared the time:

What makes this the senior-engineer tier:

• Evidence structure: the conclusion first, then four independent signals that support it. Not “trust me.”
• Distinguishes what needed action from what didn't. 47 becomes 31, 12, 3 and 1, so the reader sees in one line how much work was actually left.
• Names the residual honestly. Three customers went and bought elsewhere, which no engineering fix recovers. Instead of leaving that out, the message hands it to the team that can still act on it.
• Structural fix, not just a patch. A new monitor for the failure class, not only for this incident. It is already thinking about the next one.

1. Trigger on events, not on words. A keyword match cannot tell an incident from a question about one, so an assistant wired to a keyword will produce the same output for both and leave a human to sort them out. An assistant wired to the state of the system only starts when the state actually moves. It can post often and stay welcome, because every post came from something happening. The alarm-fatigue and interruption-cost literature exists because systems that fire on non-events reliably degrade the people they were built to help.^[6][7]
2. If your AI can't see the thread it's in, don't put it in the thread. A thread-blind assistant in chat is worse than a link to a form, because a form at least does not pretend to know anything about you. Letta's production data puts around 90% of agent failures on context rather than reasoning: the model has the capability; the plumbing around it never hands over what it needs.^[8] At minimum, read the last twenty messages. Better, read the full thread plus any linked context.
3. A tidy template can disguise the absence of analysis. The Old-School AI had the structure without the finding, which is the workslop pattern exactly: content that looks like good work but does not help finish the task.^[1] The Modern AI produced prose and took over part of a senior engineer's work. Format is the final coat of paint. The reasoning underneath is the product. Optimising the template first is a tell that the substance isn't there yet, and receivers notice: they downgrade the sender's perceived competence even when nobody discloses that AI wrote it.^[2]
4. Confidence has to be visible before the content. A long answer with “confidence: low” at the bottom is a trick rather than a caveat. If the model isn't sure, either don't answer or say so in the first line. Both the Xiong benchmark and the NAACL calibration survey document the same failure, where models verbalise high confidence on tasks their accuracy doesn't support.^[11][12] Users respond by silently discounting the assistant, but only after enough burns to form the pattern, and by then the deployment is already failing.^[13]
5. Human-in-the-loop beats fully-autonomous on high-stakes output, for now. Of the two, the one doing more of a human's job is the one that kept a human at the decision. It works ahead, prepares the options, and executes whichever one is chosen. What stays with the human is the judgement call and the accountability. Autonomy in execution with human control at the decision point is where enterprise value sits right now. Flip it, so that the human does the legwork and the AI decides what to say, and you have built the Old-School AI. IBM frames the goal as the efficiency of automation “without sacrificing the precision, nuance and ethical reasoning of human oversight,”^[14] and for high-risk systems the EU AI Act now requires that oversight by law.^[17] Klarna is the most public demonstration of what taking the human out of that loop costs on high-stakes work.^[3][4]
6. Measure whether a human actually used the AI's reply, not whether the AI produced one. The Modern AI's messages get sent verbatim. The Old-School AI's messages get followed by “can we kill this?” Measure what share of its output goes out unedited. If output needs heavy editing before use, you haven't saved anyone time, you've added a review step. That's the workslop tax made concrete, at nearly two hours of receiver time per instance, and the sending team almost never sees the bill.^[1][15]
7. Ownership language matters. The Modern AI says “this is a mistake on our side” and “we've already done X, next we'll do Y.” The Old-School AI says “root cause identified, no action needed on our side,” even when the root cause is itself. The AI that people end up trusting talks like a colleague who is answerable for the outcome, not like a diagnostic tool that emits reports. The workslop researchers name the two postures: pilots steer the AI with judgement, framing and editing, while passengers let it carry them and ship output their colleagues can immediately tell is hollow.^[1][16]

This comparison says almost nothing about model choice. Both assistants ran on the same models. The gap sits entirely in the product decisions made around the model:

• What starts it, a matched word or a changed situation.
• What context it gets before it speaks.
• How it signals doubt.
• Who makes the call on what it produces.

Underneath all four sits a simpler question, and it is the one that decides all four: what job the thing thinks it has. Answer machine, ticket bot, or colleague drafting on someone's behalf.

The BetterUp and Stanford researchers frame workslop as a management failure rather than a model failure. It shows up where a blanket “just use AI” mandate lands on teams already stretched too thin, without training, without the authority to decide, and without clear norms for when and how.^[15] The Old-School AI is what that mandate produces when nobody is asked to design the loop.

There is a more useful measure than whether you use AI: would your team be lighter or heavier if it were taken away tomorrow.

“We use AI” is not a quality claim. Two teams on the same model produced a tool that was switched off and a tool that did a senior engineer's work, in the same channel, in the same week. What separated them was the judgement of whoever designed the loop each one lives inside, meaning everything around the model that decides when it runs, what it sees, and who signs off. Four decisions, and all four are copyable.

If you're shipping an assistant into a shared channel this quarter, the cheapest change available is to stop triggering it on words and start triggering it on events. Everything else in the lessons above gets easier once the AI stops answering things that were never its job.