Notes on Data and Learning — N.16

Designing a prompt creates the impression that interaction is under control. But when you start working with real systems, that assumption quickly breaks. Behaviour does not depend only on the prompt. It depends on context.

This became very clear to me this week. While working on agent workflows and exploring Model Context Protocols, I ran into a small but persistent debugging issue: the same prompt produced different outputs depending on what the system had already seen. Adjusting the wording did not solve the problem. Adjusting the context did.

At the same time, working with JSON without full confidence made debugging more difficult. More than once I had to step back and revert to a previous working version, still unsure what exactly had broken the workflow. In some cases, I moved forward without fully resolving the issue, simply to keep the system running.

That was the moment the focus shifted.

In earlier stages of learning AI, most attention goes to prompts: how to phrase a request, how to guide the model, how to obtain a better answer.

But once systems become part of workflows, prompts are no longer isolated. They sit inside a broader context that includes previous interactions, data sources, instructions, and constraints. That context determines how the model behaves as much as the prompt itself.

You are no longer only writing prompts. You are shaping the conditions in which they operate.

Over time, the interaction also changes. The agent starts responding more naturally, even when requests are not precisely structured. This can create a sense of familiarity, almost like working with a colleague. But that apparent ease can also hide the underlying complexity of the system.

An interesting moment this week came from revisiting earlier concepts in natural language processing, particularly n-gram models. These are simple statistical approaches that model language by looking at sequences of words and their probabilities.

Compared to modern systems, they are limited. But going back to them clarified something important. Language modelling has always depended on context. Even in its simplest form, prediction depends on what comes before—and on the corpus from which patterns are learned.

What has changed is not the principle, but the scale and the mechanism.

This return to basics made the current challenges easier to interpret. What appears as complexity in modern systems often has roots in simpler structures that are easier to reason about.

This became particularly clear while working on agents and automation workflows. A single request is manageable. A sequence of dependent interactions is not.

Context starts to accumulate. It needs to persist, but also remain relevant. Too little context leads to inconsistency. Too much leads to noise. The system either forgets or becomes difficult to control.

The problem is no longer response quality. It is continuity.

Working more closely with automation workflows made this even more visible. Once an agent is placed inside a workflow, it no longer operates in isolation. It becomes part of a sequence of steps where outputs feed into new inputs, and where small variations can propagate through the system.

At first, everything appears stable. The agent responds correctly, the workflow executes, and the outputs look coherent. Over time, small inconsistencies begin to appear: context grows slightly too long, irrelevant information remains in memory, or small formatting changes alter the interpretation of the next step.

Maintaining stability becomes a continuous effort.

Training an agent, in this sense, is not a one-time task. It is an ongoing process of alignment: refining context, adjusting instructions, and deciding what should be retained and what should be discarded. Without this, systems tend to drift—not dramatically, but gradually, in ways that are difficult to detect until outputs become unreliable.

This is where workflows and context intersect. The workflow defines the sequence. Context defines the interpretation. Both need to be controlled.

Model Context Protocols attempt to formalise this layer. They define how tools, data, and interactions are exposed to the model in a structured way. In doing so, they make explicit something that is often implicit: context is part of system design.

This connects with earlier reflections. In automation, structure appears in workflows. In data, it appears in formats like JSON. In attention, it appears in prioritisation. Here, it appears in context.

The pattern is consistent. What used to be implicit now needs to be designed.

Perhaps one of the most important shifts in learning AI is this: moving from prompts to context.

Prompts are visible. Context is not. Yet context determines whether a system behaves coherently across interactions.

Learning AI may therefore increasingly mean learning how to structure context: what to include, what to exclude, and how to maintain continuity without losing control.

And once context becomes explicit, interaction stops being a single step and becomes a system.