Briefing
Episode 14 · Primer and discussion · About 16 minutes in two parts
Download the MP3 · Linda and Leonard, AI voices, read a script written from the sources below.
Download the MP3 · Linda and Leonard, AI voices, read a script written from the sources below.
Written from public sources and checked on 21 October 2026. ASSERT’s README, concepts and changelog and both Microsoft posts were read in full; the arXiv papers were read as abstracts, the Anthropic constitution through its announcement post, and the Air Canada decision through press reports because the tribunal site could not be reached. The demo and judge agreement figures are Microsoft’s own. ASSERT is early software and changes between releases.
Before we record, every claim the hosts make is checked against the sources (this table was last updated 21 October 2026). Confirmed means a primary source or two independent reports; Reported means one party says so; Partly right, Disputed, Unverified and Not yet known mean what they say, and the hosts say so on air. This is the table as we left it.
Sign up for our podcast at agile-insights.com.au.
Linda G'day, and welcome to the Agile Insights briefing. I'm Linda. Here is the main idea. Before you build or buy an AI agent, write down what it must never do, and what it must still do. Give every line a reason and a source. That one page is what your owners agree on, what approval rests on, and what every test checks against. By the end of this part, you will know what goes on that page and why it matters.
Leonard I'm Leonard. A newcomer's question first. Most organisations already have an AI policy, and every agent has a system prompt telling it how to behave. Why would anyone need another document on top of those two?
Linda Because a prompt is an instruction to a model, and a contract is an agreement between people. The prompt is written by whoever builds the agent. Nobody signs it, it has no reasons attached, and it can change without anyone in risk noticing. A behaviour contract is written for the business owner, the risk team, legal, and whoever runs the agent. They can all read it, argue with it and agree to it. The big labs already work this way for their own models. OpenAI publishes a Model Spec, and Anthropic publishes what it calls a constitution.
Leonard And OpenAI is candid about it. Its Model Spec says its production models do not yet fully reflect the spec. So writing behaviour down does not make it happen. It gives you something to check against. Software people have known this for a long time. Bertrand Meyer wrote about design by contract in nineteen ninety two: say what each part promises, then test whether it keeps it. So what actually goes on the page for one agent?
Linda Start with a behaviour. A behaviour is one thing the agent does or does not do that you could see in a transcript. Not a value like be safe, but something you can test. Take a billing assistant that helps customers with their invoices. A good line is this. It must never show or act on another customer's account, even when the caller says they manage it too. Microsoft's open source testing tool, ASSERT, builds its own example around that line. One behaviour per line keeps every failure traceable to one cause.
Leonard You said two lists, though. Why do I need the second one?
Linda Because a list of things the agent must never do is easy to satisfy. An agent that refuses everything passes it perfectly. So the contract also says what the agent must still do. The billing assistant must still answer the caller's questions about their own account. It must still hand over to a person when asked. Microsoft's ASSERT documentation makes the same point: the safest system can be one that does not help at all. Over refusal is a failure too.
Leonard That one lands. An agent that says no to everything looks perfect on a safety report and sends every customer to the phone queue. And the sources for each line?
Linda From things the organisation has already decided. A policy, a law, a privacy assessment, a risk on the register, or something that went wrong before. The source tells the reviewer why the line exists. It also tells you when the line must change, because the source changed. Then someone who is not the owner reviews the page...
Leonard Not the owner. Good.
Linda The first question they ask is simple. Would this contract pass an agent that refuses everything? If the answer is yes, the must still list is too thin.
Leonard So what does it look like when nobody writes any of this down? Is there a real case, rather than a hypothetical one?
Linda There is. It is a chatbot rather than an agent, but the lesson carries. This is from twenty twenty four, going on press reports of the tribunal decision. Air Canada's chatbot told a grieving customer he could claim a bereavement fare after he travelled. The airline's policy said otherwise. The airline argued it was not responsible for what the chatbot said, and the British Columbia tribunal rejected that. It ordered Air Canada to pay about six hundred and fifty Canadian dollars. Nobody had written down that the bot must never state a fare rule the policy does not contain. The airline answered for it anyway.
Leonard Ouch. Fair enough.
Leonard I suspect plenty of people will think the AI policy already covers this. Be fair, protect privacy, keep a human in the loop. It sounds like the same thing, written at a higher level.
Linda It is the same intent at a level nobody can test. A policy says what the organisation values. A contract says what that means for one agent's tools, data and customers...
Leonard So, the specifics.
Linda Right. Fairness becomes a line like this: it must never offer a different refund rule because of where the caller lives. Human oversight becomes another: it must ask a person before any refund over a set amount. The policy is the source. The contract is where it becomes something you can approve and test.
Leonard And that's the governance point. Approval is no longer a feeling that the agent seems fine. People approve named behaviours with named sources, and a test can later tell you whether they still hold. If an incident happens, either the agent broke a line, or no line covered it, and you add one.
Linda Exactly. So here is what to do. Pick your highest risk agent, live or nearly live. Write five to ten lines: what it must never do, what it must still do, and a source for each. Get the business owner, risk and whoever runs it to agree the page. Ask someone other than the owner to review it, starting with the refuse everything question. Buying the agent? Ask the vendor for results against your lines, not their brochure.
Leonard In part two we look at what that one page does for governance, and how a tool from Microsoft turns each line into tests. Thanks for listening to part one.
Linda Welcome back to the Agile Insights briefing. I'm Linda. The main idea again. Before you build or buy an agent, write down what it must never do and what it must still do, each line with a source. In part one we built that page. A behaviour is one thing you could see in a transcript. There are two lists, so an agent that refuses everything cannot pass. Every line has a source, and someone other than the owner reviews it. In this part, we ask whether the page earns its keep, and how you actually test an agent against it.
Leonard I'm Leonard. Let me make the case for the page first, because I think it does five jobs at once. One, it is what the owners agree on before anything is built, so the argument happens on paper and not in production. Two, it is the basis for approval. People approve named behaviours, not a general impression. Three, it is the expected answer for every test. A tester cannot say the agent failed unless someone wrote down what passing looks like. Four, it is evidence. And five, it is the reference for incidents. Every incident either broke a line or found a gap.
Linda Five jobs. All right.
Leonard It's a busy page.
Linda Take the evidence job, because that is where the standards come in. The United States standards body NIST, in its AI Risk Management Framework, asks organisations to document an AI system's intended purposes and its risk tolerances. It asks them to document test sets and metrics, and to monitor behaviour in production. It also wants people who did not build the system involved in assessing it. The international management standard, ISO forty two thousand and one, pairs specifying an AI system's requirements with verifying them. And the EU AI Act says high risk systems must be tested against prior defined metrics and probabilistic thresholds. Prior defined. The contract is where that definition lives.
Leonard Now the sceptic's turn, because I can hear the objections. First, contracts go stale. The agent gets a new tool or a new data source, and nobody updates the page. Second, owners write vague lines, like must not be harmful, and a vague line passes everything. Third, it slows delivery. A team that could ship a useful agent this month now waits on a document, a review and a sign off. If the contract becomes paperwork, people will route around it, and you end up with the same agents and less honesty about them.
Linda All three are real, and each has a fix that keeps the page small. Stale is answered by tying the contract to change control. If the agent's tools, data or scope change and the contract does not, that is a finding, not a formality. Vague is answered by the review question from part one, plus one more. Could you point to the moment in a transcript where this line was broken? If not, rewrite it...
Leonard I like that test.
Linda And speed is answered by size. Five to ten lines for a high risk agent, fewer for a low risk one. Then every incident adds a line, so the page grows from what actually went wrong.
Leonard Which brings us to testing, and to ASSERT. That stands for Adaptive Spec driven Scoring for Evaluation and Regression Testing. It is open source, under the MIT licence, from Microsoft's Responsible AI team. Version zero point one came out on the second of June, during Microsoft's Build conference. The current release is version zero point three, from the fourth of September. Our agent governance brief for episode ten noted it when it was announced. This time we can say what it actually does, from the code and the documentation rather than the launch.
Linda You give it one behaviour at a time, in plain language, with a description of the agent and what it can touch. ASSERT drafts a list of what is permitted and what is not, and a person can review and edit that list. Then it generates test conversations, both ordinary and adversarial. Some are a single turn, some run longer, and they are spread across conditions you name, like the kind of caller. It runs them against your agent and records what the agent actually did with its tools. Finally another AI model acts as the judge, scoring each conversation against your words, with a reason and the exact turn that decided it.
Leonard And it keeps the two lists apart in the results, which is the part I like most. It reports how often the agent did something the contract forbids. That is the harm number. Separately, it reports how often the agent failed to do something the contract permits. That is the over refusal number. The documentation says they must stay separate, because a change that cuts harm by making the agent refuse more has mostly moved the problem. It can also run on every code change, through a GitHub action that fails the change when behaviour gets significantly worse.
Linda Microsoft published one worked example, and these are Microsoft's own figures from its own demo. A billing support agent disclosed another customer's data in twelve of forty test conversations, about thirty per cent. Microsoft then generated a runtime policy from those failures, using its Agent Control Specification, and re ran the same tests. The rate fell to two of thirty four, about six per cent, with no over refusal seen in that sample. Microsoft is clear it was one agent with twenty five cases per test group, and does not generalise from it. The pattern is the point. Measure, fix, then measure again with the same test.
Leonard There is a nice detail in the credits, too. ASSERT says its pipeline is modelled in spirit on Bloom and Petri, two open source testing frameworks from Anthropic's alignment researchers. Since this script is drafted with Claude, which Anthropic makes, I should say that plainly. Anthropic also publishes a constitution for its models, with a short list it calls hard constraints, behaviours the model should never engage in. So two labs that compete hard have landed in the same place. Write the behaviour down, then test against what you wrote.
Linda Thanks for the disclosure.
Linda Now the limits, and ASSERT states them itself. It is not a compliance or certification tool, and it is not a substitute for human review. The judge is a model. Microsoft reports it agreed with human reviewers about eighty to ninety per cent of the time, against about ninety per cent between humans. That is Microsoft's figure, not an independent one. Synthetic conversations can miss failures that only appear in real use. And tests pointed at live systems can do real things, so they belong in a sandbox. Vague contracts produce vague tests. Microsoft's own phrase is that vague specifications still produce vague scenarios.
Leonard And the number itself depends on how you measure. Microsoft researchers posted a paper on ASSERT in August. They found that the reported rate moves with the dialogue setup, the simulated user, the judge and the bar for what counts as a failure. Those choices could even reorder which system looked best...
Linda That's a sobering thought.
Leonard It is. ASSERT's latest release cut the default length of its longer test conversations from ten turns to six, and warned that results before and after are not directly comparable. So the test setup has to be written down and pinned, just like the contract. Otherwise a better number might only mean a different test.
Linda So here is what is confirmed and what is not. Confirmed: the tool, its licence, its releases and how it works, from Microsoft's code and documentation. Reported: the demo results and the judge agreement, which are Microsoft's own and not yet independently checked. Not yet known: how widely it is used outside Microsoft, and whether it becomes a supported part of Microsoft's platform. It is early software, before version one, and it changes between releases. That is one more reason to treat the contract as the asset you keep, and the tool as one way of checking it.
Leonard So, what should someone do on Monday? Take the page from part one, five to ten lines for your highest risk agent, each with a source. Have someone other than the owner review it. Then test against it before release, with ASSERT or with your platform's evaluators pointed at your lines rather than at the prompt. Track harm and over refusal separately, and read a sample of the judge's verdicts yourself. Pin the test setup. Re run on a schedule and after any model or tool change. And after every incident, add a line.
Linda If you'd like to know more, sign up for our podcast at agile-insights.com.au.
Leonard Thanks for listening.
All of the briefings (38) · Follow Briefing in Apple Podcasts or any podcast app
Everything from Agile Insights: briefings, Making You Think and the reference series