Where we let the model drive, and where we refuse to

We build two AI systems for fiction, and they are designed to disagree with each other.

One is a co-author. It helps a person write original fiction: it plans, drafts, revises, and keeps track of the story’s world as the book grows. The other is a translation pipeline. It takes a finished novel and carries it into another language, chapter after chapter, without letting the story bend on the way across.

From the outside these look like the same kind of thing. Both are AI, both work on long fiction, both are built by the same small team. But the decision that matters most in each one is opposite. In the co-author, we let the model drive. In the translation pipeline, we refuse to. That refusal is not a limitation we are apologizing for. It is the design.

Two tasks that reward opposite behavior

The reason is simple once you name it: the two tasks reward opposite behavior from the model.

Authoring rewards latitude. A good writing assistant is one that wanders a little. You want it to notice that a scene is dragging, to suggest a character might not say that, to follow you down a subplot you had not planned. The value is in the exploring. A co-author that only ever did exactly what it was told, and nothing more, would be a worse co-author. So we built it as an agent: it works in a loop, it uses tools, it plans and then builds, and it tracks the story’s world as it goes. It is deliberately open-ended, because the job is open-ended.

Translation punishes latitude. When you translate a finished novel, there is a right answer and a great many wrong ones, and most of the wrong ones are wrong in the same way: the model decided to help. It smoothed a rough sentence the author wrote on purpose. It picked a slightly better word for a character’s name than the one used in the previous chapter. It rounded a number. Each of these is a small act of improvisation, and each one quietly corrupts the text. A translator’s job is fidelity, and fidelity and improvisation are opposites.

So the pipeline is built as the exact opposite of the co-author. It is not an agent loop. The language model does not get to decide its own control flow, or choose what to do next, or wander. The process around it is fixed and deterministic. The model is used only for the narrow generative steps where you genuinely need a language model, and everything it produces is checked before it is trusted.

Why “let it decide” fails at scale

It is tempting to think you could get fidelity from an agent too, just by instructing it firmly enough. Tell the autonomous translator to be faithful, to preserve names, to not round numbers, and let it manage itself. On a single page, this often works. The failure is a function of length.

Give an autonomous agent a very long novel and let it run, chapter after chapter, and it drifts. Somewhere around chapter forty it renders a character’s name a little differently, and then keeps using the new version. It forgets a detail established two hundred pages earlier and invents a plausible replacement. It “improves” a line. None of these are dramatic. Each one reads fluently and lands with total confidence, which is exactly what makes them expensive: nothing in the output looks wrong. The same open-endedness that makes an agent a good brainstorming partner makes it an unreliable translator over the length of a real book.

The instinct to hand the whole job to one capable agent and let it decide is strong right now, because the agents are genuinely good and it feels like the future. For creative drafting, we think that instinct is correct, and we followed it. For translation, we think it is a trap, and the longer the work, the deeper the trap.

Matching the structure to the task

The principle underneath both systems is not about fiction at all. It is about matching the control structure to the task.

Some work rewards a system that can decide what to do next. Some work rewards a system that is not allowed to. The engineering skill is telling the two apart before you build, and then being willing to build them differently even when one architecture is fashionable and the other is not. We are, at the moment, quite willing to build an agent for one product and to refuse an agent for the other, and to say plainly that this is deliberate.

Both of these systems ship in Tellura. If you write in it, you are working with the agent that wanders. If you read a translated serial in it, you are reading the output of the process that is not allowed to. They feel like one product. Underneath, they are built on opposite answers to a single question, and getting that question right for each one is most of the work.