Cogna: Building a new frontier in software

The firms that build our infrastructure, grow our food, refine our fuel, and move our goods account for roughly seventy percent of global economic output. They shape living standards more than any other slice of work. They have also been largely abandoned by the software industry.

This is not because they are backward or slow to adopt technology. It is because the economics of software have never worked in their favour. The result is a strange inversion: the industries that matter most to how we live run on worse tools than a mid-sized bank or insurance company. When grids fail, supply chains stall, or factories falter, entire economies feel it. And yet the software gap persists.

Two kinds of work

Inside these firms, work splits into two broad kinds. Execution work changes the real world. It cuts steel, pours concrete, loads pallets, drives trucks, runs machines, repairs assets, and serves customers on the ground. This is the work that matters, the reason these firms exist.

Coordination work makes execution possible. It decides which crew goes where, which job runs first, when to reroute a shipment, whether a safety flag needs escalation, how to recover when a supplier fails. These decisions are consequential. When they go wrong, crews arrive at the wrong site, shipments miss their window, maintenance gets deferred until something breaks, and costs spiral. But coordination is not the point. It exists to serve execution. The goal should be to make it as lightweight and reliable as possible, so the people doing real work can focus on doing it well.

The opposite has happened. Since the industrial revolution, execution has become far more productive. Better tools, better machines, better materials, and better methods let fewer people do more physical work. Over the same period, coordination grew. Supply chains stretched across borders. Products gained more parts. Rules expanded for good reasons: safety, quality, labour, and the environment. Firms added layers of control to manage risk at scale. What used to be simple overhead became a large share of total effort.

This creates a ceiling on productivity. When execution tools improve, coordination load often rises with them. More output creates more orders, more checks, more handoffs, more exceptions, and more reports. If coordination does not improve at the same pace, the firm does not get the full gain from better machines or better training. At a country level, that dynamic feeds the stagnation we see across many western economies, and the social strain that follows from slow wage growth and high cost of living.

Where software falls short

Computers and enterprise software, from the 1960s onward, have helped. They gave us better records, faster reporting, and tighter links between teams. They raised the ceiling on what coordination teams could handle. But the gains landed unevenly, and the industries that make and move things got the worst of it.

The problem is not a lack of data or digitisation. A modern commercial truck carries more sensors than a Tesla. A well-run plant generates more telemetry than most teams can read. These firms have invested heavily in ERPs, asset management systems, and operational technology. What they lack is the layer that turns all of this into decisions — dispatch optimization, work planning, compliance triage, production scheduling — at the speed and quality their operations demand.

Modern enterprise software falls into two camps, and neither serves this need well. The first is the packaged product. Building and maintaining a software product takes scarce skills and sustained effort, so the market has mostly rewarded products that can sell to thousands of customers with similar needs. That model works well in industries with more uniform work, like finance and insurance, and in functions that look similar across many firms, like payroll, HR, and parts of accounting.

The second camp is custom build work. When a firm's needs look unique, it hires a vendor to build software to spec. Because the build cost can swing a lot, the contract pushes everyone toward a "define it all up front" plan. That plan looks safe on paper, but it breaks down in practice. The real work has edge cases. Teams disagree on what matters. Data is messy. Requirements change mid-build as users find new needs only after they see something real. The project drifts, the bill grows, and the end tool often fails to earn trust.

Firms that make and move things live at the wrong end of this split. Their work is varied. It depends on site layout, equipment, vendors, unions, local rules, product mix, and seasonality. Even within one firm, two plants can run in very different ways. That variety makes them a poor fit for one-size products, and an easy target for costly custom builds that drag on for years. So the operational decision layer — the part that determines whether work gets done safely, on time, and on budget — remains stuck in spreadsheets and tribal knowledge.

A new economics of building

Delivering useful software has always required three kinds of effort. First, you must learn the work: how experts think, the common path, the rare path, the trade-offs, and the rules that never show up in a document. Second, you must build the software. Third, you must run it in the real world: support it, keep it safe, adapt it as the business changes, and make it reliable enough that teams trust it.

AI has changed the second part. Modern code tools can now write and revise large amounts of software fast. That drives the build cost down and speeds up change. But it does not solve the first and third parts. The hard problem now is deciding what to build, in what order, with what guardrails, and then running it in a way that stays stable as the work shifts.

That is the gap Cogna exists to close.

How we work

Cogna has built the System of Work for these critical industries, giving them the operational decision layer they have never had. We start by capturing how coordination really happens — not how org charts say it happens. We work with experts to map the flow of decisions, handoffs, data, and exceptions. We turn that into a living model of the work that gets sharper with use.

On top of that model, we build applications that solve specific, high-value problems: dispatch optimization, work scheduling, compliance triage, asset maintenance, production planning. These are not generic tools configured to sort-of-fit. They are built around the way each operation actually runs, delivering value within weeks rather than years, and designed to earn trust by proving their value on real decisions.

The system does not jump from zero to full autopilot. It earns trust in layers. It starts by helping experts make better decisions faster — surfacing the right information, flagging exceptions, laying out trade-offs. As the data improves and the model sharpens, it takes on more. But it only automates what it can do reliably, and it can always explain what it did and why.

This is how we make the long tail economic. When we can learn a process fast, build fast, and run it well, we can solve problems that used to be too specialist to justify software. We can keep improving each domain without locking the buyer into endless custom change orders. And because we design for change from day one, the system stays useful as rules, processes, and priorities shift.

What this looks like in practice

Consider a maintenance planner at a utility who spends three hours every morning pulling data from six different systems, cross-referencing crew availability, checking permit status, and building a schedule that will change twice before lunch. With Cogna, that planner walks in to find a draft schedule already built, exceptions already flagged, trade-offs already laid out. But the value is not just time saved. It is better decisions — the right jobs prioritised, the right risks surfaced, the right crews matched to the right work. The judgment calls still belong to the planner. The system just makes sure those calls are made with full visibility, not partial information and gut feel.

Or consider a logistics coordinator at a distributor who spends most of the day firefighting — reacting to delays, rerouting shipments, calling drivers. With a system that sees the whole picture and can handle the standard responses, that coordinator stops being reactive. They can catch the problem that would have cost hundreds of thousands of pounds before it happens. They can think about next week, not just survive today.

This is what it looks like when coordination starts to shrink. Not the elimination of expertise, but the amplification of it. The people who know the work best get to spend their time on the decisions that actually need them —and make those decisions with better information than they have ever had.

The work ahead

We think the next step is clear. To restart real productivity growth, firms that make and move things must become mostly execution workforces, supported by software that handles the bulk of operational decisions. People will still set goals, make trade-offs, and handle the hard calls. But the routine decisions — the ones that follow clear logic and good data — should not require human effort every time. Software should gather the facts, apply the rules, surface the risks, and close the loop. Over time, it should shrink the effort it takes to run a complex operation, and raise the quality of every decision that touches safety, cost, and delivery.

When that happens at scale, firms ship faster, waste less, and run safer. They can pay better wages, invest more, and compete without cutting corners. That is what a new productivity curve looks like in the parts of the economy that matter most.

Cogna is here to build the System of Work that makes it real.