Skip to content

KastorLab sets up secure AI in your company: a dedicated instance in Europe, or on your premises. Audit me →

FinOps · How it works

Written once, zero tokens? When you have to call a model again

At which moments a program written by an AI calls a model again, and five questions to ask your provider. For anyone tracking the cost of a recurring task.

By Yaniv Benichou Published on 9 min read

In short

At run time, a program written by an AI calls no model, unless it contains a call itself: an ordinary script contains none, and Nestor’s agent-programs are designed the same way. But the program lives on: when a model writes its change, its repair after a format change or its adaptation to another file, that is a new call, and a conversation with an assistant can be another; a call to an API model is billed in tokens. The cost of a recurring task is therefore read in moments when a model is called, not in a zero that would hold for its whole life.

Does a program written by an AI really cost nothing to run?

Here is what two pages that compare an agent with a classic automation say. In a column from April 2026, the Journal du Net writes that a simple script inserts a row into a spreadsheet “without consuming a single token” (our translation), and that a classic automation set up in twenty minutes loads, at no token cost, the Excel file that the sales team sends every week into a CRM [1]. In September 2026, Leyton points out that not every process needs an agent: when the steps do not vary, a traditional automation can cost less, run faster and behave more predictably [2].

The common reading: the program is the economical option compared with the agent. What it misses: neither page covers the upkeep of a program once it is in service, meaning its changes, its repairs and its adaptation. In the Journal du Net’s example, what happens the day the sales team renames or moves a column in its file? Depending on how it is written, the program may stop or read the wrong column, and someone then has to change it.

Our previous article showed what the model receives when it writes a program on your files. This one follows the program after it is written: at which moments does it call a model again? KastorLab develops Nestor, one of whose promises is 0 tokens per run: we have an interest in this subject, and here we look for what that zero does not cover.

The moments when a model is called in a recurring task’s life

Let us extend the Journal du Net’s example: every week, an Excel file to load into a CRM. A model writes the program, a person reviews it, then the program runs on every schedule. Later, the file changes, and the program has to be changed.

Vertical diagram. A model writes the program, a person reviews and approves it, then the program runs on every schedule with no model. Later, a file changes format or a rule evolves: a model writes the change or the fix, a person reviews the new version, and the program runs again with no model. The two navy boxes are the two moments when a model is called.

On this path, a model is called at two moments, when writing and then when changing, and not at run time. In real life, the loop repeats with every change: the diagram unrolls it without repeating it. The table lists every moment, including two that the diagram does not show: adapting to another file, and the conversation.

MomentIs a model called?What triggers it
Writing the programYes, if a model writes itThe request to create it
Running itNo, unless its code calls one [1]A schedule, a manual launch
Changing itYes, if a model writes the changeA rule that changes, a result to fix
Repairing itYes, if a model writes the fixThe usual file changes structure
Adapting itYes, if a model writes the adaptationA file other than the example
Chatting with an assistantYes, with the history [4], unless the request launches an existing agentA message sent

A developer can write the change instead of a model: the call disappears, and a person’s time replaces it. The rows without a source number are this article’s reasoning. The last row is not a program run. Anthropic’s Messages API is stateless, so the full conversation history is sent with every request [4]. As of 4 November 2026, a beta feature, “message threads”, lets you send only the new messages [4].

What this changes when you read a bill

The zero at run time is accurate for a program that contains no model call: a run without a model consumes no tokens. The lines on a bill come from the other moments. The price pages of Anthropic and OpenAI publish a price per million tokens, separate for input and for output [3]: a call that writes a program, a change or a fix is billed like a call to an API model. The cost per task, the one to track, is the sum of these moments, not the cost of a run.

Two consequences. First, the provider bills the call, not the decision that follows: a change that was reviewed and then rejected has already used its tokens. Second, a price per token does not say which moment in the task’s life a call belongs to. It is up to the product that calls the model to attach each call to a moment, and the last question in the list below is about that.

What to check with your provider

Five questions to ask a provider of programs or agents written by an AI.

  1. Does a run call a model, even in one of its steps? A good answer distinguishes the steps: a program that has a model classify a text calls that model on every run, and its cost is no longer that of a script.
  2. Which other moments call a model: change, repair, adaptation, conversation? A good answer gives the list, with the model called at each moment and where it runs.
  3. Who approves a change, and what does a rejected change cost? A good answer names a person other than the author, and says whether the cost of the call already made is visible.
  4. What does the program do when a file’s format changes? A good answer describes an explicit stop, an explanation of the difference, and a fix proposed for review rather than applied on its own.
  5. How do you see the cost of each moment? A good answer separates creation, changes and conversation, and says whether the amounts are measured or estimated.

How Nestor handles it

Nestor separates writing from running: the AI writes the agent; it runs without a model. A run of an agent program, whether written by Nestor or connected to a business template, calls no model: 0 tokens. Conversational agents (“instructions”) call a model on every turn; the conversation calls one too, except when the request amounts to launching an existing agent.

Vertical diagram. Inside the dedicated instance, you describe the task. The build model, external if allowed, writes the agent. A person other than the author approves it, then the agent runs with no model, in an isolated container with no network. When the file's format changes, the run stops and explains. A model then writes the change or the fix, and another person approves the new version.

Writing, changing, repairing and adapting an agent, however, call a model. The AI steps in to write the agent, then for each change it writes, before any approval: a rejected change has already cost tokens. This build cost is recorded and visible, as an estimate, in the Costs screen.

When a file’s structure changes, the run stops and explains what differs. For single-step agents written by Nestor, a repair can be proposed: a reviewed fix, built from the structure difference alone, for approval. The included business templates run without an AI model and are used as is on files with the same structure as the example; otherwise they are adapted, and the AI writes an adapter, reviewed by a colleague.

The author of an agent or of a change cannot approve it. Each agent keeps a version history, and the audit pack, sealed for integrity, exports per agent and per period the versions, the approvals and the fingerprints of the files read.

In the conversation, a model answers, except when the request amounts to launching an existing agent, such as “check this morning’s invoices”: Nestor then launches the agent rather than call a model, for 0 tokens, and the answer says so.

To limit what costs money, Nestor routes, in automatic mode, to the least expensive model able to do the task. A local model is not billed per token, which only holds for a model installed on the customer’s infrastructure. Corrections are targeted: at most 3 attempts, on the differences and without the values.

The recommended build model is Claude (Anthropic); in “internal only” mode, no external model is called, and the build uses a local model, which is slower and may not be enough for complex tasks. The dedicated instance is an isolated stack per company: managed by KastorLab in the European Union, or deployed on the company’s own infrastructure with the Souverain plan.

The recurring value of Nestor fits in one sentence: keeping the automation correct, provable and private over time, not writing it once. To run the exercise with your own assumptions, the simulator compares the bill of a frontier AI with the run of a Nestor agent: its amounts are illustrative (“Illustration. Figures are not contractual.”), and it mentions the agent’s build cost without counting it.

Limits

This article contains no amounts. We have measured neither the tokens of a change, nor those of a repair, nor those of a conversation on a real agent, and Nestor shows its build cost as an estimate. Caching of the common instructions with Claude is supported; we have not measured it. The table does not count the time of the person who reviews each change, nor that of a developer when a model does not write the fix.

The repair that Nestor proposes only applies to single-step agents written by Nestor: for the others, the run stops and explains, and this article does not describe what follows. We also do not describe how a request is matched to an existing agent in the conversation, or what each send to an external model contains: history, retrieved team memories, text of attached files. Finally, a program that itself calls a model in one of its steps follows a different cost profile, which the first question in the list above helps you spot.

Nestor is at version 0.1, under active development, with progressive access through a waitlist: the article describes the mechanisms of that version, not a result measured over time.

Sources

  1. Un agent IA n’est pas une solution par défaut (in French), Olga Dudko, Journal du Net, 16 April 2026, accessed 4 November 2026.
  2. Le coût caché des agents IA : pourquoi des modèles moins chers ne signifient pas toujours un modèle IA moins coûteux (in French), Aimane Essaidi, Leyton, 2 September 2026, accessed 4 November 2026.
  3. Pricing pages of Anthropic and OpenAI, accessed 4 November 2026 (no price is reproduced in this article).
  4. Using the Messages API, section “Multiple conversational turns”, Anthropic documentation, accessed 4 November 2026.

FAQ

Frequently asked questions

Does a script written by an AI use tokens every time it runs?

No, as long as its code contains no call to a model: an ordinary script runs without a model. A program that hands one of its steps to a model, on the other hand, calls that model on every run.

When do you have to call a model again for an agent that is already written?

When a model writes the change, the repair after a format change, or the adaptation to a file with a different structure. A conversation with an assistant also calls a model, except when the request amounts to launching an existing agent.

Does a rejected change cost tokens?

In Nestor, yes: the AI writes the change before any approval, so the rejection comes after the spend. The build cost is recorded and visible, as an estimate.

How do you read the cost of a task automated by a program?

By adding up the moments when a model is called: writing, changes, repairs, adaptations, conversation. A run without a model costs no tokens, but it says nothing about the other moments: ask for the cost of each one, and whether it is measured or estimated.

What about your company?

We start from your real tasks to scope AI: security, cost per task, team training.

Request an audit

Tell us who you are: we'll get back to you to scope an audit of how your company uses AI.

Book a demo

Pick a slot: you receive an invitation with a Google Meet video link.