As language models shrink and edge devices grow more capable, the missing piece for project delivery is not better tools - it is a connected, living layer of context that turns fragmented signals into shared understanding.

Framing

This article explores two related ideas. The first is the project context graph: a connected, continuously updated representation of what a project knows, built from the artefacts, systems, and communications that already exist. This is the foundational layer - the thing firms should be working towards now. The second is the capture of richer, nearer-source signals - through wearables, cameras, edge processing, and other means - that can feed into that graph as the technology matures. The evolution of large language models towards smaller, more efficient architectures points towards a trajectory where capturing signals at source and assimilating them into a structured context graph becomes not just feasible but natural. The graph is the foundation. The signals are what the foundation enables.

The technology to capture and interpret information closer to its source is improving fast. Language models are getting smaller and more efficient. Edge devices are becoming more capable. The point at which organisations can routinely process unstructured signals - conversations, observations, images, messages - and assimilate them into a structured understanding of what is happening is approaching quickly.

For project delivery, this matters because projects have always had a contextualisation problem. Information is generated constantly - on site, in meetings, in emails, in conversations. Some of it flows between systems without human involvement. But a significant part originates with people, and that part is inevitably filtered before it reaches anyone else. Communication is naturally scoped to the task at hand. People prioritise based on their own vantage point and work within limited bandwidth across an already full day. It has rarely been practical to capture the full context surrounding a piece of work when the immediate priority is getting the work done. The result is that something unremarkable to the person who observed it might be significant to someone in another discipline who understands the dependencies differently - but there was never a realistic mechanism to surface it.

The orientation problem

John Boyd’s OODA loop - Observe, Orient, Decide, Act[3] - was originally developed as a model of competitive decision-making in military operations, but it applies well to any environment where teams must repeatedly make sense of changing conditions and respond. In project delivery, that cycle runs continuously across multiple workstreams and teams. A significant portion of the time and effort in that cycle is spent in orientation - making sense of what has been observed in the context of everything else the project knows - and this is where the technology described in this article can make the most difference. The gap between reality changing and the right people understanding it well enough to act is where cost, delay, and commercial exposure quietly compound - made worse by the fact that orientation often requires multiple perspectives, each holding a different piece of the picture.

I’d call that gap decision latency. It isn’t purely a speed problem. It is a contextualisation problem - and it is the problem that Decision Intelligence, as a discipline, is fundamentally concerned with closing.

The OODA loop applied to project delivery - orientation is the primary bottleneck

What the context graph looks like

The core idea is a connected, continuously updated representation of what the project knows - one that teams can read from, contribute to, and reason over as the work evolves. Contracts, requirements, schedules, estimates, procurement records, technical artefacts, issues, decisions, communications - instead of separate islands, they become part of a shared, navigable context.

Andrej Karpathy recently described something closely related[2]: a persistent, evolving knowledge layer compiled and maintained by AI, rather than repeatedly querying raw source material from scratch. That is close to what projects need - not another chat interface over a document set, but a maintained project context that grows more useful as the work progresses. Conversational interfaces remain valuable, but the point is to build the connected substrate underneath them.

A graph database is the natural structure for this because a project is a web of relationships, not a pile of files. A work package depends on an activity; an activity depends on a drawing, a component, a supplier, a constraint. A single customer request can touch scope, commercial position, engineering effort, procurement, and schedule risk simultaneously. A graph represents those relationships directly - and when a new signal arrives, the system can place it inside the actual structure of the project. That is what turns information into orientation.

The graph also makes collective intelligence tangible. Every individual on a project holds their own connections and context. A quality assurance lead understands the dependencies, constraints, and stakeholder relationships associated with their discipline - they may see implications in a change that the project manager has no visibility of, and vice versa. The graph doesn’t replace those perspectives. They will continue to be essential for a long time to come. But by holding them in a single connected place, it enables anyone on the team to appreciate broader implications and orient themselves more fully than they could from their individual vantage point alone. The total knowledge across the team may not grow, but by connecting what was previously distributed and fragmented, the value that can be drawn from it is substantially higher.

×

A customer request for additional instrumentation, contextualised across the project graph. Click a node to inspect its properties and relationships.

From static artefacts to live signals

Most organisations already have the first layer: static artefacts like contracts, schedules, estimates, and risk logs. The second layer is more dynamic: emails, Teams messages, meeting notes - coordination that sits around formal systems but rarely feeds back into them. The third is nearer-source operational signals - and this is where the trajectory becomes most interesting.

Three layers of project information - from established artefacts to emerging signals

Think about what happens when a project schedule is built. Each line is an abstraction - a duration, a dependency, a resource. But the conversation behind it was far richer: why a task is expected to take 20 hours rather than 12, who is likely to do the work, what assumptions are being made about access or materials. That reasoning matters enormously for anyone who later needs to understand or reforecast that line. But it has never been captured. It exists for the duration of the conversation and then it is gone.

This is already changing in a limited way. Automated meeting transcripts are now common - AI summarising discussions, extracting actions, and producing minutes that would previously have relied on someone’s notes and memory. Given that a significant part of the working day is spent in meetings or conversations, that alone retains a great deal of context that would otherwise have been lost. The natural extension is capturing the conversations and observations that happen outside of formal meetings too - on site, over calls, between teams - where useful context frequently emerges but has no mechanism to be retained. It isn’t a leap to a different kind of technology. It is an extension of the capture window from scheduled meetings to the working day more broadly.

In construction and infrastructure, wearable devices already monitor worker safety. The Burger King story that gained attention earlier this year[1] - AI headsets compiling “friendliness scores” from drive-through conversations - is a consumer-facing example of the same pattern: interpreting signals at source so that leading indicators become visible before they show up in lagging measures.

The shift is not about collecting more data. It is about retaining the reasoning and context that were never practical to capture before - lost not through negligence, but because the tools, time, and effort required to preserve them simply did not justify the cost.

What this looks like in practice

Consider scope creep. A customer email or meeting note suggests additional work. That moment lands as ambiguity. Someone has to recognise it might be out of scope, locate the right contract documents, check what’s been agreed, and work out whether change control applies. That orientation process is where the delay accumulates.

In a living context graph, the same signal can be assessed against contract scope, requirements, change history, and related work packages as soon as it arrives. The system can flag that the request likely sits outside scope, surface the relevant clauses, and propose next steps. The human still decides. But the time spent assembling the picture compresses significantly.

The same pattern applies to procurement. If a site signal suggests that additional parts are now required, the context graph can connect that to the work package, the component, the supplier, the procurement status, and the likely schedule consequence - helping trigger the next step before the delay has time to compound.

Or consider package readiness. When a team is preparing to deliver a package of work, the information they need is typically spread across multiple systems: constraints, available resources, materials status, budget, contractual obligations, technical requirements, and dependencies on other packages. A living context graph can bring those inputs together so that teams start with a more complete picture of their operating environment rather than spending the first portion of their preparation reconstructing it.

In each case, the bottleneck being addressed is contextualisation, not judgement. The decisions still belong to people. The graph reduces the time and effort it takes to get them the context they need.

Design intent and governance

The same capabilities that help projects could also be misapplied. Burger King’s use of AI to assess hospitality at source isn’t inherently negative - acting on leading indicators rather than lagging complaints is a reasonable goal. But it became headline news for a reason. The idea of AI listening to how you speak at work touches on something deeply felt: privacy, autonomy, agency in the workplace. The perception of surveillance can erode trust if not handled carefully.

One of the strongest arguments for this approach is that it doesn’t have to be a black box. If an agent is reasoning over a connected graph rather than making an isolated guess, it can show its workings - which contract clause it relied on, which requirement it linked to, which prior change it matched against, and which documents support its recommendation. That gives the user something to verify rather than simply something to trust, and project professionals are far more likely to adopt tools that help them inspect the reasoning than ones that hand down conclusions.

The governance architecture needs to exist before signal capture begins, not once trust has already been damaged. The question shouldn’t be “What more can we capture?” It should be “What context do we need to improve a specific project outcome, and how do we build that in a way people can understand and trust?”

Where this is heading

Much of the AI capability needed for better project delivery is already here. The challenge now is harnessing it effectively - and that comes down to how well we can provide these systems with the context and information they need to be useful. A living context graph is how that gets done.

The practical starting point is not to attempt a universal layer on day one. Ask where your project context is weakest. Ask which decisions or workflows would benefit most from faster orientation - scope control, procurement response, package readiness, supplier escalation. Start with one specific, high-value workflow and build the context around it. The firms that do this well will not be the ones who automated first, but the ones who built useful, connected context first.

The firms that start building that foundation now - even imperfectly - will be the ones best placed to get the most from what the technology already makes possible.

References

  1. Kaye, D. (2026, 28 February). “Burger King rolls out AI headsets that track employee ‘friendliness’.” BBC News.
  2. Karpathy, A. (2026, April). “LLM Knowledge Bases” - persistent, LLM-maintained knowledge layers. Shared via X and GitHub Gist.
  3. Boyd, J. (1976). Destruction and Creation. The OODA loop (Observe, Orient, Decide, Act) was developed by US Air Force Colonel John Boyd.

RB

Rob Butler · Principal Consultant & AI and Data Lead, Kaleido Projects · LinkedIn

This article was drafted with the assistance of generative AI and reviewed and edited by the author.