Two Agents, One Queue: What Survived Building MySerene in the FCA Sandbox

Two men in dark suits and sunglasses trade punches in heavy rain, with rows of identical suited men behind them
I'm back with more Matrix references!

Three posts makes this a trilogy, and we all know how risky the third one is.

The last post ended with "Now I've started, I can't stop!" and then, evidently, I stopped. It's been a busy four months at Serene! Anyway. I promised to cover sequential execution and per-turn agents, and I will. But rather than stretch this into a series with a fourth part I'd have to promise and then deliver late again, I'm closing it off here. You get the promised bit, what held up, what I'd change, and where the framework has gone since we built on it.

If you're joining late, the earlier posts are on infrastructure and Aspire and building on the Microsoft Agent Framework.

Two agents, one queue

There's a question at the heart of any multi-agent system: do your agents run at the same time, or one after another?

The obvious answer is at the same time. Faster, more efficient, why make anything wait?

We went the other way. Every turn in MySerene runs two agents in a fixed order, every time. A third, the Tone Guidance Agent, runs separately on its own triggers.

When an advisor sends a message, the first agent to pick it up is the Compliance Agent. Its job is narrow: search our indexed material and return citations relevant to what's being discussed. Consumer Duty, FG21/1, signs of payment difficulty and more. Those citations go to the Insight Rail, the panel beside the main conversation. Then it stops. It never writes a word of conversational response.

The second is the Care Coach Agent. It starts once the first has finished, takes that compliance context as grounding, and streams an empathetic response into the main chat.

Citations first. Response second. Always.

The case for running them in parallel is latency. Start both, merge the results, shave some time off. What you lose is the relationship between them. If the Coach starts generating before retrieval has finished, its response isn't built on anything that was found. It might read perfectly well. It might even be right. But it was produced alongside the evidence rather than on top of it, and in a regulated setting I wasn't comfortable with that trade.

(Agents running in parallel and multiplying is how the Matrix got into trouble.)

I should be precise about what sequencing buys you, because it's easy to oversell. It guarantees the evidence existed before the answer was written. It doesn't guarantee the answer used it well. That's a job for evaluation, and I'll come back to it below. But you can't sensibly ask "was this grounded?" if grounding wasn't possible in the first place.

The other benefit is more mundane. A linear trace is much easier to read than a concurrent one. When mentors from regulated firms asked how this would behave in real operational conditions, "the order is the same every time" was a very short answer to a very long question.

A fresh agent every turn

The related decision took us longer to get right: we build a fresh agent instance for every turn instead of keeping a long-lived one.

A real support call doesn't stay in one place. It moves from verifying identity, to understanding the customer's situation, to exploring options, to agreeing next steps. Each phase has a different objective, different things worth saying, and a different tone.

Before we fixed this, we watched an agent with static instructions stay stuck in a phase after the conversation had moved on. It kept giving verification-flavoured answers while the customer was talking about payment arrangements. Odd to watch. It wasn't exactly wrong, it just wasn't responding to where the call actually was.

The fix is our Prompt Composer service, which builds the instructions fresh each turn. It starts from the agent's base configuration, adds guardrails and tone guidance, then injects a block describing the current task: the objective, the key actions, and the triggers for escalation. The agent registration in DI stays a cheap, long-lived singleton. The instance that handles the turn is built fresh and thrown away afterwards. You get the efficiency of one and the adaptability of the other, and the framework never fought us over it.

A man in a navy suit, pale blue shirt and mirrored sunglasses stands against a pale background with streams of green code and a stylised blue skyline
A fresh Agent proposing an alliance...

When something breaks

Every turn produces a stream of typed events: citations, tokens, escalations, tool results, and a final event to close the turn. Each one carries which agent it came from and which turn it belongs to, so the whole thing reads back in a known order.

The part I'm quietly proudest of is what happens when something goes wrong. An agent timing out or erroring doesn't cascade. It becomes a result event carrying the status, the turn carries on, and the final event still follows. The one time the final event doesn't arrive is cancellation, on purpose, because the UI treats that event as "done", and a cancelled turn isn't done.

What I'd do differently

I said I'd be honest, so here are the three things I'd change.

Evaluation from week one. We built the scenario runner and the judgement engine later than we should have. Structured scenarios and automated judgement from the start would have caught regressions faster and let us iterate with more confidence. For longer than was comfortable we were flying somewhat blind, though part of that was us getting to grips with a lot of new tooling at once. Nightly runs now track regressions as models get updated, and I wish I'd had them on day one.

Treat tone guidance as a proper subsystem. The Tone Guidance Agent grew organically. It now has idempotency logic, fingerprinting to avoid redundant runs, its own event store and a collection of trigger types. None of that was a bad idea, but it all arrived one sensible increment at a time, and it should have been designed as a first-class piece from the start.

Write the decision down when you make it. We added Architecture Decision Records late. The decisions that really shaped the system, sequential over parallel, per-turn agents, the event model, were made in the moment and then lived on as institutional knowledge. Writing each one down would have taken twenty minutes. I've been paying interest on those twenty minutes ever since, which is mildly embarrassing, though in my defence this was a fast-moving experimental sandbox.

Where the framework has gone

In the last post I said the instability we absorbed during the preview was gone. I'd like to be a bit more careful than that.

I should be upfront: the Sandbox build never moved to 1.x, because it was archived before we got there (more on that below). The renames and the rest of this section come from the docs and release notes rather than from upgrading that code.

The core is genuinely stable. Microsoft shipped 1.0 in April with stable APIs and a commitment to long-term support, and sequential orchestration is still a first-class pattern, built with the AgentWorkflowBuilder class that the docs still point you to.

The renames to expect when moving from a preview build, based on the migration notes:

  • Threads have become sessions, with the matching changes to how you create them.
  • The Azure AI package has been folded into a Foundry one.
  • The ReflectingExecutor was obsoleted in favour of source generation.

The thing I'm genuinely curious about is checkpointing. The docs pitch it for long-running workflows, but also for periodic state saving for auditing or compliance purposes. We built our own event trail during the Sandbox, and I'm curious how much of it overlaps. It would be a pleasant problem if some of that code could be deleted.

And a correction to my own optimism: the stable core doesn't mean nothing moves. The pieces around it are still in motion. The A2A integration went through a breaking migration to a new SDK version in April, and the durable extension is still shipping breaking changes in preview. If you're choosing features, check which side of the line each one sits on.

A man in a dark high-collared coat hangs suspended in a rushing green-lit tunnel, staring straight ahead through tinted glasses
He came here to tell you how it's going to begin

Where MySerene has gone

The MySerene I've been describing was the Sandbox build, and that codebase has now been archived. That's less dramatic than it sounds. It did what it was built to do, and its successor has moved on quickly as we work with clients on real-world use cases.

Some of the decisions in this post made the journey and some didn't, which is rather the point of a prototype.

It's still MySerene, and it's built on the current release of the Agent Framework, though the preview left me with a habit that stuck: I still read the release notes before bumping a package version. The rest stays private for today!

That's the series

Three posts: how we got moving with Aspire, why we picked the Agent Framework, and this one. If something here was useful, or you think one of these decisions is wrong, tell me on LinkedIn or Bluesky. I'd rather hear it.

Thanks for reading, and for putting up with the Matrix references.

I'm CTO at Serene, where we are building ML and AI-powered tools for financial services advisors. MySerene is our multi-agent platform for real-time, compliant customer support guidance. We were part of Cohort 1 of the FCA AI Supercharged Sandbox.