Insights · Articles
Articles
Deeper technical breakdowns of how we build AI and data systems — weekly.
The Decision Plane: A Pattern for Multi-System Operations
A WMS, a TMS, and an ERP each make locally sensible decisions all day, none of them aware the other two exist. The decision plane isn't a fourth system. It's the layer that lets the other three stop deciding blind.
Operator Screens for the Human-on-the-Loop Role
We inherited a monitoring dashboard built for an autonomous system's operators: forty tiles, twelve charts, a status feed. The operator's actual job — catching the one action worth stopping — was nowhere on the screen. We rebuilt it around that job specifically, and thirty-six of the forty tiles didn't survive.
Decision Provenance Stores: A Reference Architecture
A regulator asking why a claim was denied and an engineer asking why accuracy dropped 4 points on Tuesday are asking the same question in different vocabulary: what evidence, model version, and policy produced this decision.
Bring-Your-Own-Agent Runtimes: A Design Note
Different teams want different agent frameworks. Your platform can either fight that or design for it. Here's what designing for it actually requires.
Planner-Executor Meshes vs. Single Agents: A Practitioner's Note
A single ReAct-style loop is the right default until it isn't. Here's the actual signal that tells you when to split planning from execution — and what it costs you when you do.
Tracking Outcomes into Year Five
An institution can tell you its four-year graduation rate with confidence. Ask what its graduates are actually doing in year five, and most go quiet — not from indifference, but because the data trail runs out.
Network-Level Routing in a World of Local Optimizers
Three regional dispatchers, each optimizing their own lane, each hitting their number. The network they share still ends the week $180,000 over plan. Here's the arithmetic on how that happens.
Cause and Correlation: A Practitioner's Field Guide
Your dashboard says churn correlates with support-ticket volume. It doesn't tell you whether fixing support tickets will reduce churn. Here's how to tell the difference before you spend the budget.
Supplier Intelligence as a System, Not a Spreadsheet
Ask a plant who its most reliable casting supplier is and you'll usually get a confident answer and no way to check it. The knowledge is real. It's just stored in a place that leaves with the person who holds it.
Outcomes Intelligence in Higher Education: A Student-Journey Ontology
Most institutions track attendance, grades, and financial aid in three systems that don't talk to each other. The fix isn't a fourth dashboard — it's a shared model of what a student's journey actually consists of.
Action Provenance: The Runtime as the Audit Trail
The separate compliance log, hand-maintained alongside the real system, is almost always the weaker record — written after the fact, by whoever remembered to write it, in whatever detail they had time for. The runtime's own execution log doesn't have that problem, if you let it be the audit trail instead of building a second one.
Closed-Loop Autonomy: Why Sense-Decide-Act-Verify Is the Unit of Work
Most automation projects fail quietly at the fourth step, not the first three. The verify stage is the one teams skip, and it's the one that determines whether autonomy is actually safe to extend.
The Cost of the Restricted-Fund Reconciliation Cycle
Picture a finance lead the Tuesday before quarter close, eleven grant agreements open in different tabs, reconciling a chart of accounts that was never designed for the restrictions layered on top of it. That Tuesday is the modal Tuesday, and it costs more than the week it visibly takes.
Theory of Change as a Data Model: A Practitioner Note
Most nonprofit data systems track activities — people served, sessions delivered, dollars disbursed. Almost none track the logical chain connecting those activities to the outcome the funder actually cares about. Here's how to build a system that does.
Automation Without Erasure: Designing Systems That Defer to Judgment
The riskiest financial automation isn't the kind that gets it wrong. It's the kind that gets it right so consistently that the humans who were supposed to catch the exception stop looking.
Supervisory Agents: The Mesh That Watches the Mesh
A planner-executor mesh doesn't fail by crashing. It fails by drifting — quietly looping, quietly narrowing its own tool use, quietly ignoring a policy nobody re-checks after the first call. None of that trips an error handler. It needs its own watcher.
Forward Supplier Intelligence: From Incident Review to Continuous Signal
The supplier risk review starts the same way almost everywhere: a missed shipment, a root-cause meeting, and a timeline that shows the warning signs were sitting in someone's data for six weeks before anyone looked.
Notes from Seven Regulatory Regimes: A Comparative View
Seven overlapping regimes, one control layer, and a firm that had built eleven versions of essentially the same identity-verification control before anyone noticed the duplication.
Prescriptive Optimisation: Where the Constraint Set Comes From
We once handed a client a production schedule that solved their stated problem perfectly. They rejected it in the first review — not because the math was wrong, but because the constraint that mattered most had never been written down.
Plant-to-Plant Transfer: Building Once, Deploying Across the Network
A model that works at Plant A and needs six weeks of rework to run at Plant B wasn't built for a network. It was built for Plant A, and everything after that is a second project wearing the first one's name.
Sovereign Deployment: When the Cloud Cannot Be the Default
On-prem AI deployment is usually framed as a paranoia tax. Sometimes it is. But there's a specific, narrow set of conditions under which it's the only architecture that actually satisfies the requirement — and most teams reach for it for the wrong ones.
Admissions Intelligence: Modelling Yield Without Modelling People
There's a version of admissions analytics that predicts whether an offer converts, and a version that predicts what kind of applicant is worth an offer in the first place. We will only build the first one.
Longitudinal Outcome Tracking: Ethics, Consent, and Method
Tracking a beneficiary's outcomes three years after a program ends is not a data engineering problem wearing an ethics costume. It is an ethics problem that happens to require data engineering — and treating it the other way around is how longitudinal studies quietly become surveillance.
The EU AI Act in the Runtime: A Practitioner's Reading
Most EU AI Act compliance work we see happens in a binder: a risk classification memo, a conformity assessment, a policy document. Almost none of it happens in the system that's actually making decisions — which is where the obligations actually bite.
Audit Evidence as a Surface, Not a Document
We stopped asking clients how long the audit pack takes to assemble and started asking whether the question changed the answer. Almost always, the pack was already stale before it shipped.
Decision-Level Tracing with OpenTelemetry
A compliance officer asked us why an automated approval fired at 2:14am. We had the service logs. We did not have the decision — the specific evidence, weighed in what order, against what policy version. Fixing that meant treating each decision as a span, not a log line.
Faculty Workload Models That Reflect the Actual Work
A three-credit course is not three credits of work. Every generic teaching-load formula assumes it is, and every provost who's tried to use one to plan a semester has watched it fall apart on contact.
Event-Driven Agent Meshes on Kafka
Eleven agents calling each other directly worked in the demo. In production, one slow downstream call stalled the whole chain and left no record of where it died. We rebuilt it as a mesh, and the rebuild changed what we could promise to operate.
Cost-to-Serve as a Live Number
A cost-to-serve report that takes two weeks to build is answering a question about a network that no longer exists by the time anyone reads it. The fix isn't a better spreadsheet. It's not treating cost-to-serve as a report at all.
Semantic Memory: Why Ontologies Outlast Models
Every model generation your team adopted in the last three years is already, in some sense, deprecated. The one artifact from that work still paying dividends is the ontology, built once and maintained deliberately.
Model Risk Management as a Property, Not a Project
Every model inventory we've inherited was accurate on the day someone finished building it. The gap between that day and today is the whole problem, and it isn't a documentation problem.
Reading the Plant Floor: Sensor Fusion for Operational Decisions
A control room with a SCADA trend, a vibration monitor, and a thermal feed running on separate screens isn't giving anyone more information — it's giving them three separate jobs. Fusion only earns its name when it collapses those into one decision.
Eval-Driven Release Gates That Actually Gate
Ask a team when their eval suite last blocked a release, and you usually get a long pause, then an example from eight months ago. That gap is the whole problem: a gate that never closes isn't a gate, it's a report.
Heterogeneous Model Routing: Cost as a Design Axis
The LLM bill arrived three times over forecast, and the instinct was to renegotiate the per-token rate. The actual lever was sitting in the application layer the whole time: nobody had built a router.