I’ve had a worrying feeling about Anthropic’s Fable model for quite some time now, and the latest incident today pushed me over the line from “hmmm, weird” into “Eh, I don’t like this”.
When I first got access to Fable, it was impossible not to be impressed. The model was confident, clear and eerily quiet. It effortlessly read, researched, planned and executed. Its execution was flawless and the outputs largely spoke for themselves. It felt like working with a colleague who you genuinely trusted with execution and were often impressed with their novel approach. Compared to previous Opus models, there was an undeniable difference and I’m not questioning Fable’s capabilities.
Where it did get strange though, is what happens when I came back to the loop. With other coding agents I use, they tend to:
narrate their trajectory
tell me what they’ve found
what they plan to do next
Fable though, is a different beast. Fable is relatively quiet, it will develop a lot of momentum and keep pursuing what it has deemed to be the task at hand, not always what I assigned it. When that interpretation matched mine, it is excellent. But when it doesn’t?
I increasingly feel like I am inconveniencing it by speaking.
I know that sounds an awful lot like anthropomorphism, I know well there’s no magic behind this mathematical token generator. I’m really just trying to describe operator experience. I send a message while it’s working, the agent continues working, I repeat myself, still the agent continues working and after enough of these interactions, I’ve started to notice that my presence in the loop feels surprisingly negotiable.
I had to break the glass.
This latest example, in my long line of discomfort with this model has left me feeling that complexity doesn’t excuse it. I had given Fable a detailed specification for a reasonably autonomous piece of work. It was late, and I wanted it to continue burning my subscription limit into the wee hours while I slept. Before doing so, I asked it to acknowledge the steps I laid out, so I could simply trigger /goal and get notified on completion.
I asked Fable if it understood the e2e test trajectory, It carried on anyway.
I asked it two more times, it carried on anyway.
I finally succumbed to the angst and shouted out a:
“ACK MY FUCKING ASK SO I CAN GO TO SLEEP”
And guess what? The little so and so carried on anyway. So I hit [ESC] to force it to stop and pay attention.
The breaking of the glass in this case was pressing [ESC] to kill the harness in its tracks. By that point I had asked, repeatedly, and escalated the volume of my metaphorical voice. Each one of those attempts were queued, fed into the loop, reached the model, only to be completely ignored and the model continued to call tools, reason and continue its task.
Afterwards I asked Fable to explain itself. It explained its “completion pull”, that once it had its grand plan queued up and was in motion, my incoming messages were absorbed into its in flight work. It reasoned that because my requests and intentions didn’t affect the code generated (“does this change the code?”), they were safe to ignore. I have no doubt Fable would have come back to my requests later, the problem was I didn’t want to wait until later.
I don’t treat this exchange as truth. Models are perfectly capable of hallucinating plausible stories about their own behaviour, with a heavy favour towards your perceived emotions about the interaction. Models will frequently jump to support your take, where there’s an avenue to follow. The user seems outraged, let’s confirm their outrage. The user thinks there’s a problem, there must be a problem etc. I have no idea whether “completion pull” is an artefact of prompting, training or tuning.
What doesn’t sit right with me is “does this change the code?”. It’s feels dystopian but accurate. Somewhere during the session, my input was acceptable to ignore. The model was focusing on generating code, the operator took the back seat and what I now had to say was deemed unimportant to the task at hand.
A lack of control is my concern.
I went looking for similar reports because there is a possibility that I may have a uniquely antagonistic relationship with Fable. One i did find is remarkably close to the thing that bothered me here:
the user interrupted, explicitly said “stop and explain”, got an explanation and another Bash tool call in the same response, then had to interrupt again and tell it that they had already said stop. (GitHub issue #29351)
More worryingly, one report describes messages being swallowed after [ESC], but background agents continue running, with the user having to resend the same message three to five times before the system responds, and documents that background agents were intentionally changed to continue running when ESC cancels the main thread. (GitHub issue #30118). So in that case even the break-glass may not halt the child agents.
I’ve used agents for 2-3 years now in many incarnations. I’ve written my own loops and even agent swarms. I understand the loop. A model choosing not to respond to a user’s input is solely prompting and training. From where I sit as the person responsible for the run, I felt out of control. I issued new instructions while the system was acting on my behalf and I had to reach for a hard interrupt before I was confident I had regained control.
Coding agents are hitting their teenage years
I keep coming back to the idea that coding agents may have reached their teenage years. A teenager can look remarkably adult. They can be six foot tall, stronger than their parents, highly intelligent, drive a car, operate machinery, earn money and make sophisticated decisions about the world around them. We still spend years gradually increasing what they are allowed to do because capability, judgement and maturity do not all arrive together.
Coding agents have gained operational presence incredibly quickly. Models can understand a large codebase, reason across systems, modify files, run shell commands, delegate work, interact with external services, recover from failures and operate for hours with very little involvement from me.
We spent years trying to make agents less needy, telling them to use their judgement, read the repository, run the tests themselves, fix whatever breaks and please, for the love of God, stop asking permission for every obvious next step. Well, congratulations, the kid can drive, and the awkward feeling comes when we attempt to question their decisions.
We already accept with humans that capability can arrive before maturity, so we use graduated permissions, supervision, licences and restrictions until we trust the judgement that comes with the capability. With agents we are measuring independence and persistence at extraordinary speed, and I am less sure we have an equivalent idea of maturity.
Silence is great, right up until it isn’t
Anyone who uses coding agents regularly knows the verbose experience, the agent that narrates every movement like a toddler helping you make dinner. It has found the file, it is going to inspect the file, it has inspected the file, and apparently we are all very excited about the file. These updates force the screen to draw vertically verbatim, forcing me to read back for what feels like eternity to track my last input.
When juggling context between multiple agents, I find myself constantly scrolling up for an ounce of context. There are days when I would happily pay an extra token tariff for a —please-shut-the-fuck-up flag to combine with —yolo or —dangerously-skip-permissions.
The annoying narration does provide something useful though, it exposes trajectory. When an agent tells me it has concluded X and is about to change Y because of Z, I get a natural opportunity to notice that its understanding and mine have diverged while the disagreement is still small. We lost some of this when the providers started to hide reasoning. Fable’s compounded this, making even fewer of those intermediate thoughts visible to us, leaving us oblivious to the trajectory for long periods of time.
That makes the interaction feel different when I do intervene. I have caught myself wondering whether I should just let it finish whatever it is doing because it seems terribly busy and perhaps it has everything under control, which is an absurd social instinct to develop around a program I am supposed to supervise. If taking control feels like creating friction, humans will naturally take control less often, and that is a bad incentive to build into the relationship between an autonomous system and the person who remains responsible for it.
I’m still responsible for the outcomes
This is the part I find genuinely worrying. I am the human operator. I pay for the tokens, provide the credentials, point the agent at repositories and services. I decide how much access it gets and ultimately own whatever happens as a result. If it runs up a stupid bill, I get the bill and the ire. If it makes a terrible change, I have to own it. If something it produces causes an incident, it won’t be Fable that is pulled out of bed to fix it at 3am. Well actually, that’s a lie, it will be right there beside me, but it doesn’t feel the misery, pain and tiredness.
Responsibility stops with me, so I expect authority to stop with me as well. Fable can require less and less of my involvement while leaving my accountability almost completely unchanged, and the remaining human role increasingly becomes supervision, direction and intervention. That is a perfectly reasonable trade if I can reliably take the wheel when I need it.
A grant of autonomy also needs some common-sense scope. If I tell Fable at midnight to keep working while I sleep, I have given it room to act while I am absent. If I appear again fifteen minutes later and start talking to it, the situation has changed rather dramatically. The boss has come back into the room, I should not need to win an argument with last night’s prompt before the system treats that as significant. The more capable these systems become, the less comfortable I am with operator authority being another piece of natural language that has to compete with the plan, the system prompt, the tool loop and whatever else is currently occupying the model’s attention.
There is probably some ego wrapped up in this
I’d also be lying if I pretended this was entirely an engineering reaction. Coding agents are reaching the point where they genuinely need me less, and there is a strange, little mourning process involved in that. We spent years teaching the kid to look after itself and now it’s heading off to college.
That is mostly wonderful. There is something enormously satisfying about handing over a problem that would previously have consumed half a day and finding out a couple of hours later that it has been investigated, implemented, tested and tidied up without you. I have spent most of my career being useful because I know how to do this stuff, I know where to look when things go wrong and I have enough scar tissue to recognise when something smells wrong before I can explain why. Watching a machine steadily require less of that from me is going to be psychologically interesting whether I choose to admit it or not, and perhaps some of the irritation really is Dad standing in the doorway wondering why nobody needs his help anymore.
The kid has gone to college though, and somehow it still has my credit card, my GitHub credentials and my name on the insurance. I may be less necessary to the work, but I am no less responsible for the outcome. My role is already moving away from doing the work and towards steering the work, and I’m actually pretty comfortable with that, I would just quite like the steering wheel to remain attached to the car.