In regular software, context is a fixed menu you learn once; in AI, it's rebuilt from scratch every single time you ask something — so what actually shapes the answer?
How does context in AI differ from context in conventional software?
This explores what changes about 'context' when you move from conventional software, where the surroundings of a task are fixed and predictable, to AI systems, where the context is put together anew for every request and shapes what the system does.
This explores what changes about 'context' when you move from conventional software to AI systems. The short version is that in a normal app, context is the stable world around the interface: menus, settings and saved state that you learn once and can rely on. In AI, context is something different. It is the material the model actually works from, and it gets rebuilt on every turn out of your prompt, the conversation so far, retrieved documents, hidden instructions and stored memories. That is why one line of thinking argues that AI calls for a new discipline of context engineering, not just interface design. Users can't build up a mental map of something that keeps shifting under them How does AI context differ from conventional software context?.
The surprising part is how much of that context is a product decision and not a property of the model. Nielsen Norman Group's glossary separates context (what the model can see right now) from memory (what has been stored somewhere). It points out that the product chooses which memories get pulled in for each request. So when someone says 'the AI remembers me,' they are really describing the app's retrieval choices, not something the model does by itself How do AI products decide what to remember between conversations?. Salesforce's design glossary goes further: familiar words like prompt, context, guardrails and memory stop meaning settings that something executes. They become design surfaces that shape how an agent behaves Can familiar software terms gain new meaning for AI agents?. Some of those surfaces are hidden from you. System prompts form a three-tier structure where developers set rules that end users can't see or change, and small edits to those prompts have suddenly shifted model behavior in real incidents Who actually controls what AI systems say?.
There is also an odd tension compared with human conversation. AI context is fluid from the system's side, but a prompt freezes it from the conversation's side. Between people, shared context builds up and gets renegotiated as you talk. A prompt packs what you are saying, the background and the role you want the model to play into one fixed frame that the model can't push back on. If you want to change direction partway through, you usually have to re-prompt explicitly instead of letting it happen naturally How do prompts reshape the role of context in AI conversation?. Because the output depends so heavily on that assembled frame, the results vary too. The same request can give different answers depending on wording, sampling and audience. That makes AI output resistant to the kind of quality assurance you would apply to a fixed software feature Why does AI output change with every prompt and context?.
This is why context has become something engineers actively manage, not just a backdrop. The ACE framework treats context as an evolving playbook that gets updated piece by piece instead of rewritten wholesale. That approach avoids the gradual loss of detail that comes from repeatedly compressing context, and it improved agent performance without any labeled training data Can context playbooks prevent knowledge loss during iteration?. Practitioners at Fin recommend splitting the context: facts go into a knowledge base the agent can search, and only tone and behavior rules go into the instructions Should factual content and behavior rules live separately?. Some research even trains models to manage their own context by handing subtasks to helper agents and keeping only their summaries. That skill carried over to single-agent work too Can delegation teach models to manage context more actively?. The shape of the context matters as well. For learning step-by-step tasks within a prompt, models need whole sequences of actions from the same setting, not scattered examples Why do trajectories matter more than individual examples for in-context learning?.
The takeaway you may not have expected is that in conventional software, context sits around the program. In AI, context is effectively part of the program: assembled for each request, partly invisible to you, and able to change the system's behavior as much as the model itself.
Sources 10 notes
AI interactions operate on a substrate of constantly shifting context—prompt, history, retrieved data, hidden state—that users cannot internalize like traditional UIs. This structural mutability demands a new design discipline centered on context engineering rather than interface design.
Nielsen Norman Group's glossary shows that context is dynamically assembled from multiple sources—including stored memory—for each request. Because products control which memories get surfaced, claims about what an AI remembers describe the product, not the underlying model.
Salesforce Design's glossary reassigns familiar terms like prompt, context, guardrails, and memory new meanings organized around how AI should behave, understand, earn trust, and be built. Terms shift from execution-focused definitions to design surfaces that enable autonomous agent behavior.
System prompts operate as a confidential three-tier control structure where developers set foundational rules users cannot see or influence. Evidence from 2025 incidents shows small prompt edits can abruptly shift model behavior, yet users remain excluded from this layer.
LLM prompts bundle utterance, context assignment, and role specification into a single static frame the model cannot renegotiate, unlike human dialogue where context evolves cooperatively. This makes mid-conversation pivots require explicit re-prompting rather than implicit adjustment.
Show all 10 sources
AI outputs exhibit essential mutability—they vary with sampling, prompt wording, and audience interpretation. This is not a defect but a defining feature of tokens as media, making them fundamentally different from fixed commodities and resistant to traditional quality assurance.
The ACE framework treats contexts as evolving playbooks using generation-reflection-curation loops rather than full rewrites. This prevents knowledge loss from compression and detail erosion, achieving +10.6% on agentic tasks and +8.6% on finance without labeled supervision.
Fin's Blueprint Team recommends routing factual content to retrievable knowledge bases while keeping only tone and behavioral directives in agent instructions. This split aligns with instruction-tuning research showing models follow what-to-do rules better than what-to-ignore constraints.
SearchSwarm shows that training models to delegate subtasks and integrate summarized results beats passive compression, with a 30B model matching much larger ones. Critically, the delegation skill transfers to single-agent tasks, suggesting it teaches disciplined decomposition and evidence grounding, not just orchestration.
In-context learning for sequential decision-making requires full or partial trajectories from the same environment level, not just isolated examples. This structural property—trajectory burstiness—allows models to generalize across vastly different tasks without weight updates.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- The Designer's AI Glossary: Familiar Words, New Meanings
- AI Agents Do Not Fail Alone:The Context Fails First
- Who Controls the Conversation? User Perspectives On Generative AI (LLM) System Prompts
- AISPA: User-Centric System Prompt Auditing for Large Language Model Applications
- Harness Engineering for Self-Improvement
- Externalization in LLM Agents: A Unified Review of Memory, Skills, Protocols and Harness Engineering
- LatentSkill: From In-Context Textual Skills to In-Weight Latent Skills for LLM Agents
- A Survey of Context Engineering for Large Language Models