Insights

Steerable by Whom?

Why the model inside a customer-loyal agent should be one we host and pin, and why code still commits

Steerable by Whom? Why the model in a loyal agent should answer to the customer. Wendy MacKinnon. The model answers to the mandate.

In my first post, I argued that a large language model should not hold the authority to spend our money. It is probabilistic, and it can be steered. The answer to the first problem is to keep authority in code: the mandate, the counterparty check and the receipt. The model proposes. The code commits.

I also said a model can be steered in two ways: by what it reads, and by whoever owns it. This post is about the second.

Two kinds of steering

01
Steered by what it reads
A hidden instruction in a web page, an email or an invoice.
02
Steered by whoever runs it
A new version, a revised system prompt, a changed commercial priority.

The first gets most of the attention, and rightly so. Controls in code are how you contain it.

The second is quieter. A model reached through someone else’s service can change at any time, and the customer whose agent relies on it would not know.

For most software, that is an ordinary vendor relationship. For an agent that acts for a customer, it is a loyalty question. If an agent works for you, the model inside it should not answer to anyone else.

The model answers to the mandate.

Our approach

Twinvocate does not use a language model today. Where we introduce one, most likely to help find and propose suppliers, the design calls for three things:

01
Self-hosted
It runs on infrastructure we control, so mandate, payment and counterparty information does not travel to a model provider.
02
Version-pinned
It does not change unless we change it, test it and record that we did, so what we test is what runs.
03
Sponsor-free
No platform or advertiser sits behind it, and code excludes sponsored results from supplier sourcing.

Why this is now practical

Not long ago, hosting your own model meant accepting a much less capable one. That gap is closing. Open-weight models, which anyone can download, run and inspect, are now competitive on many of the tasks agents do.

Mistral’s announcement of Mistral Large 4 in late October is one recent example: a very large open-weight model aimed at coding and agentic work, with the weights intended for organizations to run in their own environments.

We are not choosing a model yet, and the job we have in mind is much narrower than what the largest models are built for. A smaller open model may well be enough. The point is that the trade-off has changed. Choosing control no longer means giving up much capability.

What I will be watching

Self-hosting raises its own questions. These are the ones I am following:

Where Twinvocate fits

Self-hosting does not replace the controls in code. A model we host is still probabilistic, and it can still be steered by what it reads. That is why it only proposes. The mandate, the counterparty check and the receipt stay in code, whatever model sits upstream. Self-hosting closes the other door: no one outside the mandate can change how the model behaves.

Twinvocate is at the prototype stage. The mandate and receipt are in code in the prototype. The counterparty check runs in a separate engine that is not yet connected to the agent, and conduct constraints are designed but not yet built. The self-hosted model approach described here is a design principle, and no model is in use. There has been no live or sandboxed processing of real data.

I would welcome hearing from others working on open models, agent governance or payments about how they are approaching this.

Probabilistic is handled by code. Steerable is handled by who controls the model.

An agent that holds our wallet needs both.

Sources

Wendy MacKinnon is the founder and CEO of Twinvocate, a Toronto company building a customer-loyal AI agent and a certified-counterparty credentialing layer for agentic commerce.

All insights