Anton, chapter 7: Becoming operational

At some point, a project stops asking whether it works and starts asking different questions.

What does it cost?

What happens when a provider fails?

What information can escape?

What does the system do when nobody is watching?

Anton crossed that threshold over the next two weeks.

Three threads defined the period: cost became part of the architecture, the syndic domain tested the system against a large real-world problem, and a heartbeat gave Anton a quiet form of awareness between requests.

Cost is part of correctness

Every model call gained a token budget.

History was trimmed before the provider request rather than waiting for an API error. Calls carried attribution metadata: agent, domain, user, and request ID. Selected requests were duplicated to cheaper models in the background so I could compare results without affecting production.

Anton needed to know what it cost.

Not only for budgeting, but because sudden changes in usage are often evidence of a behavioural regression.

Memory consolidation moved from every write to a nightly batch. Importance scoring decided what survived, and a dashboard showed the health of the memory system.

The earlier design had been spending money on work no one needed to happen immediately.

Then an OpenAI billing problem stopped requests in the middle of the day.

Automatic fallback to other providers followed.

The lesson was direct:

If a provider is a single point of failure, your reliability is their reliability.

A fallback should be part of the normal architecture, not an emergency patch.

One source of truth

I removed the last hardcoded prompt fallbacks.

Every agent prompt already lived in the database. Keeping stale copies in code created two possible truths, and the system could silently choose the wrong one.

Now a missing prompt failed loudly.

A missing configuration is a problem. Quietly running yesterday's behaviour can be a worse one.

Validation also learned to distinguish a complete answer from an agent that had merely exhausted its tool-call budget. When a delegate stopped halfway, the parent could invoke it again rather than presenting partial work as final.

A whole class of silent incompleteness disappeared.

The syndic test

The condominium-management domain was the first feature large enough to test nearly every architectural decision Anton had accumulated.

It began with foundations: schemas, skills, email ingestion, file registration, and document processing.

Heavy ingestion happened outside the interactive assistant. Anton queried the resulting structure.

That division mattered. The user-facing agent should not spend its time repeatedly performing expensive background work.

The first extraction pipeline sent every PDF through vision.

It worked, and it was far too expensive.

The next version tried deterministic tools first: Pandoc for Word documents, pdftotext for PDFs, and vision only when extraction returned unusable results.

The cheap path handled most files and was roughly an order of magnitude faster.

The rule from the browser returned:

Scout with the LLM. Build the common path deterministically.

The documents then became a structured wiki. Anton could answer questions from organised sections rather than rereading an archive on every request.

The goal was no longer to extract text. It was to build a representation the rest of the system could query.

The browser scouts an API

SimplySyndic was initially controlled through the browser agent.

Then I inspected what the browser was actually doing.

Every screen mapped to stable HTTP calls.

The browser came out. Direct synchronisation went in.

No browser. No LLM. Fewer moving parts.

Once the data was structured, bank reconciliation could match almost every BRED CSV line to a SimplySyndic entry automatically. Fund calls became rows rather than text fragments.

The same idea was tested and reinforced with SNCF train departures. The browser workflow worked, but a deterministic HTTP route was around a hundred times cheaper for a task that would run every morning.

So I reverted the clever version.

Cost discipline beats cleverness.

A loop that knows whether a fix worked

Anton's self-improvement process also matured.

It could already identify failures and file issues. Now it tracked deployments, ran smoke tests after a deploy, detected regressions, and connected a new failure to the change that introduced it.

A loop that proposes fixes but cannot determine whether they worked is not closed.

The system needed a memory long enough to notice that a problem had returned.

Scheduled tasks were tightened at the same time. Every notification path passed through the same gate. Scheduled mode gained stricter output rules: no filler, no unrequested follow-ups, follow the specification exactly.

A scheduled message is an interruption. It should earn the interruption.

The heartbeat

Then Anton gained a heartbeat.

The heartbeat surveys operational state and speaks only when something requires attention.

It does not invoke domain agents or take corrective action. It looks; it does not do.

That separation is deliberate.

A background observer with permission to act can quietly become a second autonomous system. A survey loop is easier to understand: collect state, compare it with expectations, and notify when necessary.

The heartbeat gave Anton a kind of awareness between conversations without giving that awareness unlimited agency.

Finally, every outbound message moved through one gateway.

WhatsApp, Telegram, and notifications all used the same path, which recorded the sender, channel, recipient, content, and originating agent or scheduled job.

One chokepoint. One audit trail.

The period ended with two wonderfully revealing bugs: a heartbeat scratchpad serialization problem and a date-extraction error in the issue filer.

The system watching the system had developed problems of its own.

Small projects do not have meta-bugs.

Operational systems do.

By then, Anton's concerns were no longer only capabilities. Cost, fallback, attribution, audit, and self-observation had become first-class parts of the design.

The syndic domain proved the earlier architectural rules could survive contact with a messy real problem.

And the heartbeat marked a subtle transition.

For the first time, Anton was doing something between requests.

For now, that something was simply paying attention.