Insights
Research, not recycled takes.
What we're learning building AI agents, ML systems, and data infrastructure — written for engineers and leaders who'd rather read something new than something familiar.
The Data Foundation Gap
Nearly every manufacturer is now running an AI pilot. Almost none of them are running it on a data foundation built to support it. This report looks at the layer connecting PLCs, SCADA, MES, and ERP — where most industrial AI initiatives quietly stall — and lays out the architecture that fixes it.
The Confidence Interval as a First-Class Output
A forecast that says "440 units" is a different claim than one that says "440 units, plausibly anywhere from 310 to 590." Most decision systems we inherit only ever emit the first one.
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.
Outcomes Over Activities: What Boards Are Starting to Ask For
A board member recently asked a program team not how many workshops ran this quarter, but what changed for the people who attended, and how the team knows. The silence that followed is becoming a pattern.
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.
Demand Sensing in a Six-Plant Network: What We Learned Re-baselining Nightly
We pitched nightly re-baselining as a modeling upgrade. It turned out to be a data-plumbing project wearing a forecasting project's clothes, and the difference cost us a month we hadn't planned for.
MCP, A2A, and the End of Vendor Agent SDKs
Model Context Protocol and Agent-to-Agent are quietly doing to agent tooling what HTTP did to proprietary networking stacks — and it changes what you should build in-house.
Ninety Days to Unify Five Legacy Systems: A Sequencing Note
The original plan had us designing the unified data model for six weeks before touching anything live. We scrapped it in the first planning meeting, and that turned out to be the right call.
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.
Designing for Safe Degradation
Under uncertainty, most autonomous systems do one of two things: keep going as if nothing changed, or stop entirely. Both are the wrong default. The right one is a known, deliberately narrower mode the system falls into on purpose.
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.
Glass-Box Explainability That Holds Up at Audit
We walked into a model review with a beautiful SHAP dashboard and walked out with homework. Here's what the risk committee actually wanted, and why our first answer wasn't it.
Escalation by Consequence: A Threshold Design Note
Six weeks after launch, our override rate quietly hit zero. We treated that as good news for about a week before we realized what it actually meant.
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.
What-If as a System, Not a Workshop
Ask most operations teams when they last ran a what-if scenario and they'll point to a planning offsite months ago. Ask what changed about how they handle an actual demand shock next Tuesday, and the honest answer is usually nothing.
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.
Responsible Prediction in Education: What We Refuse to Build
Most vendor conversations about responsible AI in education stay abstract on purpose. Ours doesn't — here are the specific things institutions have asked us to build that we've turned down, and why.
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 Reconciliation Problem That Eats Optimization Budgets
Ask most supply chain optimization projects what they actually spent their first six months on, and it wasn't optimization. It was getting the ERP, the WMS, and the TMS to stop disagreeing about what's true.
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.
The Cost of the Unreconciled Inventory Number
The MES says 4,200 units. The ERP says 3,850. The shift lead's spreadsheet says 4,000 even, because that's what it said yesterday and nobody's corrected it since. All three numbers are 'the inventory position.' None of them are wrong, exactly — that's the actual problem.
Agent FinOps: A Runtime Concern, Not a Procurement One
A signed enterprise agreement with better per-token pricing feels like the finish line on agent cost control. It's the easiest 20% of the problem, and the 20% procurement is already equipped to solve.
The Hidden Cost of the Queue: Where Compliance Exceptions Actually Live
The automation rate everyone reports is the wrong number. The number that actually determines your compliance cost is how long an item sits in the exception queue before a human looks at it.
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.
Three Reasons Manufacturing AI Projects Stall After Pilot
The pilot works. Everyone claps. Then eleven months pass and the model is still running on one line, in one plant, watched by the two engineers who built it. Here's where that gap actually comes from.
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.
Field Data Capture in Low-Connectivity Environments
\"Offline mode\" is the wrong mental model for field data capture where connectivity is the exception, not the fallback. A system designed around that reality looks different from one that's merely offline-capable.
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.
The Week-Six Signal: Why Most Interventions Arrive Too Late
Midterm-based early warning systems are accurate and almost useless, because by the time they fire, most of the semester's runway for changing a student's trajectory is already gone.
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.
Why Most Funder Reports Take Weeks (and What to Do About It)
A funder report is not hard to write. It is hard to assemble — and the assembly is where three weeks go, quarter after quarter, no matter how good the program was.
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.
The Control Surface Inventory: A Starter Method
Most compliance teams can name their controls but not the systems those controls actually touch. That gap is where the surprises live, and it's fixable in a quarter with a method this plain.
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.