Context Engineering: Techniques, Tools, and Implementation

Part 1: The Foundations of Context Engineering

Defining the Paradigm Shift: From Prompting to Context Engineering

The performance of Large Language Models (LLMs) is fundamentally determined by the contextual information provided during their inference process.¹ In the nascent stages of applied generative AI, the primary method for interacting with these models was "prompt engineering," a practice centered on crafting a single, well-phrased instruction to elicit a desired response. However, as AI systems have evolved from simple question-answering tools into complex, multi-step agents capable of sophisticated reasoning and task execution, the limitations of this approach have become starkly apparent.² This has given rise to a more mature, systems-level discipline known as Context Engineering.

Formal Definition of Context Engineering

Context Engineering is formally defined as the systematic discipline of designing, organizing, orchestrating, and optimizing the complete informational payload provided to a Large Language Model at inference time.¹ It transcends the crafting of a single instruction to encompass the entire information ecosystem that an AI system requires to perform tasks accurately, reliably, and consistently.³ This discipline is frequently encapsulated by a quote from AI researcher Andrej Karpathy, who describes it as the "delicate art and science of filling the context window with just the right information for the next step".⁶ This definition shifts the focus from the user's immediate query to the carefully curated environment of information the model operates within, ensuring it receives the right data, in the right format, at the right time.³

The necessity for this discipline stems from a fundamental shift in how developers build and deploy AI. As powerful base models from providers like OpenAI, Anthropic, and Google, alongside high-quality open-source alternatives, have become widely accessible, the competitive advantage in AI applications is no longer solely derived from possessing a superior proprietary model. Instead, differentiation comes from the unique data and operational logic an organization can provide to a model at runtime. An LLM, no matter its power, cannot solve specific enterprise problems without access to internal knowledge bases, user histories, and business rules.³ Context Engineering is the formal practice that operationalizes this differentiation, providing the architectural patterns to reliably integrate this proprietary information into the model's reasoning process.

The Limitations of Prompt Engineering at Scale

Prompt engineering, while a valuable skill, is fundamentally a practice of crafting a static, single-turn instruction.¹¹ It focuses on "what you say" to the model in a given moment. This approach proves insufficient and brittle when applied to the demands of industrial-strength AI applications, which are inherently dynamic, stateful, and often involve multiple interactions over time.¹¹

The core limitation is one of scope. A cleverly worded prompt alone cannot manage conversation history, retrieve real-time data from an API, or maintain a persistent understanding of a user's preferences across multiple sessions.³ Consequently, failures in complex applications—such as a customer service bot that forgets a user's issue mid-conversation or an AI coding assistant that is unaware of the project's overall structure—are rarely due to a poorly worded prompt. Instead, they are failures of context.¹⁴ These systems require a dynamic understanding of "everything else the model sees," including examples, memory, retrieved documents, and available tools.⁶ The reliance on manual prompt tweaking for each edge case is not scalable, leading to inconsistent and unpredictable behavior in production environments.¹¹

Historical Evolution and Coining of the Term

The underlying concept of providing situational information to computational systems is not new, with deep roots in fields like human-computer interaction and context-aware computing.³ However, the specific term "Context Engineering" began to gain significant traction within the AI community around mid-2025. Its popularization is largely attributed to influential figures such as Shopify CEO Tobi Lutke and was amplified by Andrej Karpathy.⁸

This terminological shift was not merely a rebranding of prompt engineering; it signaled a critical evolution in the collective understanding of how to build with LLMs.⁸ It moved the conversation away from the "magic words" of a prompt and toward the rigorous, architectural challenges of information management.¹⁶ The rapid adoption of the term reflected a growing consensus among practitioners that the primary bottleneck for building robust AI agents was not the inherent capability of the LLM, but the quality, relevance, and structure of the information provided to it.²

The Core Philosophy: Engineering the Model's "Worldview"

At its heart, the philosophy of Context Engineering is to construct a dynamic, task-relevant "worldview" for the AI agent at every step of its operation.¹¹ This reframes the developer's role from that of a "prompt crafter" to that of a "systems architect" for the model's cognitive process. This perspective is powerfully captured by the analogy of an LLM as a new kind of operating system (OS).⁷

In this paradigm, the LLM itself functions as the central processing unit (CPU)—a powerful, general-purpose reasoning engine. The context window, in turn, acts as the system's Random Access Memory (RAM)—the volatile, working memory where all the information for the current computational step is loaded. Traditional software development involves writing deterministic code. Prompt engineering, by contrast, often feels like coaxing a non-deterministic function, an approach that is inherently unreliable for production systems.¹¹

Context Engineering aligns with the OS analogy by treating the developer's job as building the software layer that manages what gets loaded into the LLM's "RAM" at each turn. This "OS layer" is responsible for managing memory (both short-term and long-term), loading data from "disk" (via Retrieval-Augmented Generation), and providing access to "peripherals" (tools and APIs).¹⁴ This implies a significant evolution in the skill set required for advanced AI development, prioritizing expertise in systems design, data architecture, and workflow orchestration over a singular focus on machine learning modeling.¹¹ The objective is to transform the LLM from a simple text-completion machine into an intelligent, collaborative partner capable of understanding nuance and executing complex workflows.³

Table 1: Prompt Engineering vs. Context Engineering: A Comparative Analysis

This table synthesizes comparative data from sources ¹¹, and.¹¹

The Anatomy of Context: A Taxonomy of Informational Components

The "context" provided to an LLM is not a monolithic block of text but a carefully assembled payload composed of multiple distinct components. These components form a hierarchical and interdependent "Context Stack," where the design and quality of each layer influence the overall performance and reliability of the AI system.²³ Effective context engineering requires a deep understanding of this anatomy and the interplay between its parts.

System-Level Instructions and Persona Framing

At the base of the Context Stack lies the system-level instruction, or system prompt. This is the foundational layer that defines the AI's overarching role, personality, behavioral rules, and operational constraints.¹⁴ For example, a system prompt might instruct the model to "Act as an expert legal assistant specializing in contract law. Your responses must be formal, cite relevant clauses, and you must never provide financial advice".¹² This initial framing serves as a crucial guardrail, guiding the model's tone, style, and decision-making throughout the entire interaction.²³

Dynamic Context: User Input and Session State

This layer comprises the most immediate and transient information. It includes the user's direct input or query, but also other dynamic elements that are relevant to the current task, such as the current date and time, the user's geographical location, or the state of the application interface (e.g., which filters are currently selected).⁹ This information provides the immediate impetus for the AI's response.

The Role of Memory

Memory is the component that allows an AI system to move beyond stateless, single-turn interactions and engage in coherent, personalized dialogues. It is a critical element for any application that requires continuity.²⁶ Memory in context engineering is typically bifurcated:

• Short-Term (Conversational) Memory: This refers to the management of the immediate history of an interaction. It involves retaining the last few turns of a conversation within the context window to ensure the AI can understand follow-up questions and maintain a logical flow.¹⁸ The primary challenge here is managing the limited space of the context window, often requiring strategies to summarize or truncate older parts of the conversation.²⁷
• Long-Term (Persistent) Memory: This involves storing and retrieving information across different sessions. It enables personalization by allowing the AI to "remember" user preferences, key facts about the user (e.g., their name, location, past purchases), or the outcomes of previous interactions.¹² Implementing long-term memory necessitates an external storage system, most commonly a vector database, where memories can be embedded and retrieved based on semantic relevance.¹⁸

External Knowledge: The Primacy of Retrieval-Augmented Generation (RAG)

Retrieval-Augmented Generation (RAG) is widely considered a cornerstone and foundational pattern of context engineering.³ It is the primary mechanism for providing the LLM with external knowledge that was not part of its original training data. This is essential for several reasons: it allows the model to access up-to-date information, grounds its responses in factual, verifiable sources (thereby reducing hallucinations), and enables it to answer questions about proprietary or domain-specific data (e.g., a company's internal product documentation).¹⁵ The RAG component is responsible for searching a knowledge base (such as a collection of documents in a vector store), retrieving the most relevant chunks of information, and injecting them into the context window alongside the user's query.¹⁴

Tools and APIs as Actionable Context

This component fundamentally extends an AI's capabilities from pure text generation to taking actions in the digital or physical world. The context provided to the model includes two key aspects of tool use:

1. Tool Definitions: The model is given a description of the tools it has access to, often in a structured format like an API schema. This tells the model what a tool does, what arguments it requires, and what kind of output it produces.¹⁴
2. Tool Outputs: After the model decides to call a tool, the system executes that tool (e.g., calls an external API) and the result is fed back into the context window. This allows the model to reason based on the real-world information it has just obtained.⁷

Structured Data and Output Schemas

The final component involves the use of structured data. The context can include information formatted as tables, JSON, or XML, which can be more token-efficient and less ambiguous than natural language for certain types of data.¹⁴ Conversely, the context can also include an output schema (e.g., a JSON Schema) that instructs the LLM to format its response in a specific, machine-readable way.¹⁸ This is critical for ensuring reliability when integrating LLMs into larger, deterministic software workflows, as it makes the model's output predictable and parsable.

The management of this multi-layered Context Stack presents the central technical challenge of the discipline. Every component—system prompts, memory, RAG results, and tool definitions—consumes valuable tokens within the LLM's finite context window.³ This creates a fundamental tension between the need to provide a

comprehensive context for high-quality reasoning and the need to maintain an efficient context to manage latency, cost, and the risk of performance degradation.²¹ At every turn of an interaction, the context engineering system must solve a complex optimization problem: what information is most valuable to include, and what must be excluded, compressed, or summarized? This optimization challenge is the primary driver behind the development of the advanced techniques that define the state of the art in the field.

Part 2: Advanced Techniques in Context Orchestration

Building upon the foundational components of context, this section explores the advanced, state-of-the-art techniques that researchers and engineers are developing to address the core optimization challenges of context management. These methods represent a move from simple context assembly to sophisticated context orchestration, enabling more powerful, efficient, and reliable AI systems.

Mastering Retrieval-Augmented Generation (RAG)

While basic RAG is a cornerstone of context engineering, production-grade applications require more advanced strategies to overcome the limitations of naive vector search. The evolution of RAG techniques reflects a broader maturation in AI systems design, shifting from single-step, monolithic processes toward multi-stage, modular pipelines. This allows for specialized components to handle distinct sub-tasks, such as broad candidate retrieval versus precise relevance ranking, leading to improved overall performance, greater control, and enhanced debuggability.²⁸

Advanced Retrieval Strategies

Hybrid Search

Naive semantic search can sometimes fail on queries that depend on specific keywords or acronyms that may not have strong semantic overlap with the relevant documents. Hybrid search addresses this by combining the strengths of two different retrieval paradigms: traditional keyword-based search (e.g., TF-IDF or its modern successor, BM25) and semantic vector search.³⁰ BM25 excels at exact-match and term-frequency relevance, while vector search excels at understanding the user's underlying intent and meaning.³² By fusing the results from both methods, a hybrid system can achieve more robust and accurate retrieval across a wider range of query types.

A practical implementation often involves using an EnsembleRetriever, which runs queries against both a keyword retriever and a vector retriever and then combines their results using a weighted scoring mechanism.

# Code Example: Implementing Hybrid Search with LangChain

# This example demonstrates setting up a hybrid retriever using LangChain.
# It assumes 'documents' is a list of LangChain Document objects.

from langchain_community.retrievers import BM25Retriever
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.retrievers import EnsembleRetriever

# 1. Initialize the keyword-based retriever (BM25)
bm25_retriever = BM25Retriever.from_documents(documents)
bm25_retriever.k = 5 # Retrieve top 5 results

# 2. Initialize the semantic vector store and retriever
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(documents, embeddings)
vector_retriever = vectorstore.as_retriever(search_kwargs={"k": 5})

# 3. Initialize the EnsembleRetriever to combine results
# The 'weights' parameter balances the contribution of each retriever.
# Here, we give equal weight to both semantic and keyword search.
ensemble_retriever = EnsembleRetriever(
    retrievers=[bm25_retriever, vector_retriever],
    weights=[0.5, 0.5]
)

# 4. Use the hybrid retriever
query = "What are the key financial risks mentioned in the report?"
hybrid_results = ensemble_retriever.invoke(query)

print(f"Hybrid search retrieved {len(hybrid_results)} documents.")
for doc in hybrid_results:
    print(f"- {doc.page_content[:100]}...")

Code adapted from the principles described in.³⁰

Re-ranking Algorithms

Re-ranking introduces a crucial second stage to the retrieval process, creating a two-pass architecture designed to maximize precision.²⁹ The workflow is as follows:

1. First Stage (Retrieval): A fast, recall-oriented retriever (like a vector search or BM25) is used to fetch a large set of candidate documents (e.g., the top 50-100 results). This stage is optimized for speed and aims to ensure that all potentially relevant documents are included in the candidate pool.³⁴
2. Second Stage (Re-ranking): A more powerful and computationally expensive model, typically a cross-encoder, is then used to score each of the candidate documents against the query. Unlike bi-encoders used in vector search (which create separate embeddings for the query and documents), a cross-encoder feeds the query and a document together into the model.³³ This joint processing allows the model to capture much finer-grained interactions and nuances, resulting in a more accurate relevance score. The documents are then re-ordered based on these scores, and only the top-k (e.g., top 3-5) are passed to the LLM.²⁹

This two-stage approach effectively balances the trade-off between speed and accuracy. The initial retrieval is fast enough for large-scale search, while the re-ranking stage applies deep semantic analysis only to a small, manageable subset of documents, ensuring the final context provided to the LLM is of the highest possible relevance.²⁹

Graph-RAG

Graph-RAG represents a paradigm shift from retrieving unstructured text chunks to retrieving structured knowledge from a Knowledge Graph (KG).³⁵ In a KG, information is stored as a network of entities (nodes) and their relationships (edges). This approach offers several advantages over traditional document-based RAG:

• Contextual Richness: It can retrieve not just facts but the relationships between them, providing a more holistic context for reasoning.³⁷
• Explainability: The retrieved graph structure can make the LLM's reasoning process more transparent, as the path of information can be traced.³⁷
• Multi-Hop Reasoning: It enables the system to answer complex questions that require connecting information scattered across multiple sources by traversing paths in the graph.³⁵

A typical Graph-RAG workflow involves identifying key entities in the user's query, querying the KG to extract a relevant subgraph around those entities, and then "linearizing" this subgraph into a textual format that can be fed into the LLM's context window, often alongside results from a traditional vector search.³⁵

Contextual Retrieval

Proposed by researchers at Anthropic, Contextual Retrieval is an innovative pre-processing technique designed to solve the "context conundrum" where individual document chunks, when isolated from their original source, lack sufficient context to be retrieved effectively.³⁹ The method works by using an LLM to automatically generate a short, chunk-specific explanatory summary that is prepended to each chunk before it is embedded and indexed.

For example, a chunk containing the sentence "The company's revenue grew by 3% over the previous quarter" is ambiguous on its own. Contextual Retrieval would transform it into something like: "This chunk is from an SEC filing on ACME corp's performance in Q2 2023; the previous quarter's revenue was $314 million. The company's revenue grew by 3% over the previous quarter".³⁹ This added context makes the chunk's embedding far more meaningful and retrievable. This technique has been shown to dramatically improve retrieval accuracy, reducing the rate of failed retrievals by 49% when combining contextual embeddings with contextual BM25, and by up to 67% when a re-ranking stage is also added.³⁹

Table 2: A Taxonomy of Advanced RAG Techniques

This table synthesizes information from sources ³⁰, and.³⁵

Managing the Context Window: Compression, Pruning, and Summarization

The advent of LLMs with extremely long context windows—up to 1 million tokens or more—initially suggested that the challenges of context management might disappear.⁴⁰ The tempting approach was to simply "stuff" as much information as possible into the prompt. However, empirical research and practical experience have revealed that this naive strategy is deeply flawed. The management of the context window remains a critical area of context engineering, driven by the need to mitigate specific failure modes associated with long contexts.

The "Lost in the Middle" Problem and Other Context Failures

A key finding in long-context research is the "Lost in the Middle" effect.⁴⁰ LLMs exhibit a U-shaped performance curve when processing long sequences: they are highly effective at recalling and reasoning about information placed at the very beginning or very end of the context window, but their performance drops significantly for information buried in the middle. This undermines the assumption that all information in the context is treated equally.

Beyond this recall issue, long contexts are susceptible to several other well-defined failure modes, marking the maturation of context engineering into a discipline of reliability engineering focused on preventing specific errors ⁷:

• Context Poisoning: When a hallucination or factual error from a previous turn is included in the context, the model may repeatedly reference and build upon this incorrect information, amplifying the error over time.⁷
• Context Distraction: An overly long or verbose context can overwhelm the model's foundational training, causing it to focus too heavily on patterns or irrelevant details within the context while ignoring its broader knowledge.⁷
• Context Confusion: Superfluous or noisy information in the context can be misinterpreted by the model and used to generate a low-quality or irrelevant response.⁷
• Context Clash: As an interaction progresses, new information or tool outputs may be added to the context that conflict with earlier information, leading to inconsistent or contradictory behavior.⁷

Context Compression

Context compression techniques aim to reduce the token count of the input while preserving its essential semantic meaning. This is an active area of academic research, with several distinct approaches:

• Selective Context: This method operates by identifying and pruning informational redundancy within the input text. By making the context more compact, it has been shown to achieve a 50% reduction in context cost, leading to a 36% decrease in memory usage and a 32% decrease in inference time, all with only a minor drop in performance metrics.⁴⁵
• Context-aware Prompt Compression (CPC): This is a sentence-level technique that uses a specially trained, context-aware sentence encoder to assign a relevance score to each sentence in a document relative to a given question. Sentences with lower scores are removed, compressing the prompt while crucially preserving the human readability of the remaining text.⁴⁶
• Recurrent Context Compression (RCC): This approach employs a recurrent architecture to process the input in segments and compress each segment into a much shorter vector representation. This method has demonstrated impressive compression rates of 32x or more while maintaining high performance on tasks like passkey retrieval and long-text question answering.⁴⁷

Context Pruning

While compression often refers to pre-processing the entire context, pruning typically refers to the post-retrieval filtering of documents. A leading technique in this area is Provence (Pruning and Reranking Of retrieVEd relevaNt ContExts). Provence is a lightweight model, often based on a DeBERTa architecture, that is trained to identify and remove irrelevant sentences from retrieved passages.⁴⁸ A key innovation is that it can be implemented as a second prediction head on a standard re-ranking model. This allows it to perform both re-ranking of documents and pruning of sentences within those documents in a single forward pass, making the pruning step effectively "zero-cost" in terms of additional latency.⁴⁸

Context Summarization

Summarization is another widely used technique for managing long contexts, particularly for conversational history or lengthy documents. It involves using an LLM to generate a condensed summary of the information, which is then used in the context instead of the full text.⁴² This can be done through two main strategies:

• Extractive Summarization: Identifies and extracts the most important sentences or phrases directly from the source text.⁵¹
• Abstractive Summarization: Generates new text that captures the core meaning of the source material, allowing for more concise and fluent summaries.⁴¹

The choice of strategy and the quality of the summarization are critical, as poor summarization can lead to the loss of important information. The performance of summarization is often evaluated using metrics like ROUGE (which measures word overlap with a reference summary) and more advanced methods that assess factual coverage and alignment.⁵³

Table 3: Overview of Context Compression and Pruning Methods

This table synthesizes information from sources ⁴⁵, and.⁴⁸

Context Engineering for Agentic Systems

AI agents, defined as systems that use LLMs as reasoning engines to autonomously perform tasks by planning and using tools, represent the most complex application of context engineering.⁵⁴ The effectiveness of an agent is almost entirely dependent on how well its context is managed at each step of its execution loop.

Single-Agent Architectures

In a single-agent system, the LLM operates in a loop of reasoning, acting, and observing. Context management is crucial for maintaining state and enabling complex problem-solving. Two key mechanisms are employed:

• Scratchpads: A scratchpad is a designated area within the context where the agent can "think out loud" or store intermediate results and plans.⁷ This allows the agent to break down a problem and track its progress without cluttering the main conversational history.
• Memory Modules: As discussed previously, dedicated memory modules are used to manage both short-term conversational state and long-term persistent knowledge, allowing the agent to learn and adapt over time.⁷

Multi-Agent Systems

For highly complex tasks, a single agent may be insufficient. Multi-agent systems decompose a problem and assign different sub-tasks to a team of specialized agents that collaborate to achieve a common goal.⁵⁷ This approach introduces significant context management challenges but also opens up new possibilities for parallelism and specialization. The design of these systems reveals a fundamental trade-off in AI architecture: the tension between the

coherence of a single reasoning process and the parallelism offered by distributed computation.

A single, powerful agent, empowered by meticulous context engineering, can maintain a highly coherent and consistent state, avoiding the coordination overhead and potential for conflicting information that plagues multi-agent systems.⁵⁷ This approach prioritizes reliability and consistency. Conversely, for tasks that are easily decomposable, such as conducting research on multiple independent topics, a multi-agent approach can be far more efficient by parallelizing the work.⁵⁸ The future of agentic architectures likely lies in hybrid systems, where a top-level "orchestrator" agent manages the overall task to ensure coherence but can dynamically spin up temporary, specialized sub-agents to handle parallelizable sub-problems.⁵⁹

Common architectural patterns for multi-agent systems include ⁶⁰:

• Linear "Swarm" (AgentWorkflow): Agents hand off control to one another in a sequential or dynamic chain.
• Hierarchical "Orchestrator": A central supervisor agent directs tasks to a pool of subordinate agents, which are treated as tools.
• Custom Planners: A bespoke system where an LLM generates a structured plan (e.g., in JSON or XML) that is then executed by a separate orchestration engine.

The primary challenge in these systems is context coordination.⁵⁷ Key strategies include:

• Context Sharing: Using a shared memory or state object (like the state in LangGraph) to ensure all agents have access to a consistent, unified view of the task's progress and relevant information.⁵⁷
• Context Isolation (Quarantining): Deliberately keeping the contexts of different agents separate to prevent them from interfering with one another or being distracted by irrelevant information. This is crucial when agents are performing highly distinct tasks.⁷

Frameworks like LangGraph are specifically designed to address these challenges by representing agentic workflows as cyclical graphs, providing robust tools for managing state, persisting context, and orchestrating complex interactions between nodes.⁵⁷

Security and Sandboxing

A critical, and often dangerously overlooked, aspect of context engineering for agents is security. When an agent is given tools that can execute code, access filesystems, or make arbitrary network calls, it becomes a potential attack vector. Inadequate sandboxing is listed as a top security risk for LLM applications.⁶³

A malicious prompt could trick an agent into executing harmful code (e.g., os.system('rm -rf /')), reading sensitive files (e.g., /etc/passwd), or exfiltrating data to an external server.⁶³ To mitigate these risks, any code or command generated by an LLM agent must be executed within a secure, isolated sandbox environment.

Mitigation strategies include:

• Environment Isolation: Using technologies like Docker containers or gVisor to create a heavily restricted execution environment with no access to the host system, limited network capabilities, and strict resource limits.⁶³
• Secure Execution Libraries: Utilizing open-source libraries like llm-sandbox, which provide a simple API for running LLM-generated code in a secure, pre-configured containerized environment.⁶⁴
• Access Control and Validation: Tightly scoping the permissions of any tools given to the agent and validating all parameters before execution to prevent abuse.⁶³

Part 3: Implementation, Case Studies, and the Future Horizon

This final part of the report grounds the theoretical concepts and advanced techniques of context engineering in practical application. It provides detailed code examples using leading open-source frameworks, analyzes real-world case studies to demonstrate business impact, and concludes with a forward-looking analysis of the field's trajectory, including critical research gaps and profound ethical considerations.

Practical Implementations and Open-Source Ecosystem

The principles of context engineering are best understood through implementation. The open-source community has produced a rich ecosystem of tools and frameworks that enable developers to build sophisticated, context-aware AI systems.

Code Walkthroughs

The following examples demonstrate how to implement key context engineering patterns using popular Python libraries.

Building a Long-Term Memory Agent with LangChain

This example showcases the creation of a conversational agent that can persist and recall information about a user across different sessions. It uses LangChain's StateGraph for orchestration and an in-memory vector store for long-term memory.

# Code Example: Long-Term Memory Agent with LangChain and LangGraph

import uuid
from typing import List
from langchain_core.documents import Document
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableConfig
from langchain_core.tools import tool
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langgraph.graph import START, END, StateGraph
from langgraph.prebuilt import ToolNode
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph.message import MessagesState

# 1. Setup Memory Store and Tools
embeddings = OpenAIEmbeddings()
vector_store = FAISS.from_texts(["initial document"], embeddings)

# A simple way to associate memory with a user
def get_user_id(config: RunnableConfig) -> str:
    return config["configurable"].get("user_id", "default_user")

@tool
def save_memory(memory_content: str, config: RunnableConfig) -> str:
    """Saves a piece of information to the user's long-term memory."""
    user_id = get_user_id(config)
    doc = Document(page_content=memory_content, metadata={"user_id": user_id})
    vector_store.add_documents([doc])
    return "Memory saved."

@tool
def recall_memories(query: str, config: RunnableConfig) -> List[str]:
    """Recalls relevant memories for the user based on a query."""
    user_id = get_user_id(config)
    # Filter search to only include documents for the current user
    results = vector_store.similarity_search(query, filter={"user_id": user_id}, k=2)
    return [doc.page_content for doc in results]

tools = [save_memory, recall_memories]

# 2. Define the Agent Graph
class AgentState(MessagesState):
    pass

llm = ChatOpenAI(model="gpt-4o")
llm_with_tools = llm.bind_tools(tools)

def agent_node(state: AgentState, config: RunnableConfig):
    # First, recall relevant memories based on the conversation so far
    conversation_history = "\n".join([msg.content for msg in state["messages"]])
    recalled = recall_memories.invoke(conversation_history, config)
   
    # Construct a new prompt with the recalled memories
    system_prompt = f"""You are a helpful assistant with a long-term memory.
Here are some relevant memories from past conversations:
<memories>
{recalled}
</memories>
Now, continue the conversation."""
   
    prompt = ChatPromptTemplate.from_messages([
        ("system", system_prompt),
        ("placeholder", "{messages}"),
    ])
   
    chain = prompt | llm_with_tools
    response = chain.invoke({"messages": state["messages"]})
    return {"messages": [response]}

def tool_router(state: AgentState):
    last_message = state["messages"][-1]
    if last_message.tool_calls:
        return "tools"
    return END

builder = StateGraph(AgentState)
builder.add_node("agent", agent_node)
builder.add_node("tools", ToolNode(tools))
builder.add_edge(START, "agent")
builder.add_conditional_edges("agent", tool_router)
builder.add_edge("tools", "agent")

memory = MemorySaver()
graph = builder.compile(checkpointer=memory)

# 3. Run the Agent
config_user1 = {"configurable": {"thread_id": "1", "user_id": "user_123"}}
graph.invoke({"messages": [("user", "Hi, my name is Alex and I work as a data scientist.")]}, config_user1)
graph.invoke({"messages": [("user", "My favorite hobby is hiking.")]}, config_user1)

# In a new session, the agent can recall the information
config_user1_new_session = {"configurable": {"thread_id": "2", "user_id": "user_123"}}
response = graph.invoke({"messages":}, config_user1_new_session)
print(response['messages'][-1].content)

Code inspired by the long-term memory agent tutorial in ⁷⁹ and.⁷⁹

Implementing a Multi-Agent Workflow with LlamaIndex

This example demonstrates the "orchestrator" pattern, where a top-level agent directs tasks to specialized sub-agents.

Python

# Code Example: Multi-Agent Orchestrator with LlamaIndex

from llama_index.core.agent.workflow import AgentWorkflow, FunctionAgent
from llama_index.core.tools import FunctionTool

# Assume llm is an initialized LlamaIndex LLM object

# 1. Define Tools for Specialist Agents
def search_web(query: str) -> str:
    """Searches the web for information on a given query."""
    # In a real implementation, this would call a search API
    return f"Web search results for '{query}': The web was invented by Tim Berners-Lee."

def write_report(topic: str, notes: str) -> str:
    """Writes a report on a topic using the provided notes."""
    return f"## Report on {topic}\n\nBased on the research, {notes}"

# 2. Create Specialist Agents
research_agent = FunctionAgent(
    name="ResearchAgent",
    tools=,
    llm=llm,
    system_prompt="You are a research specialist. Use the search tool to find information."
)

writer_agent = FunctionAgent(
    name="WriterAgent",
    tools=,
    llm=llm,
    system_prompt="You are a professional writer. Use the write_report tool to compose reports from notes."
)

# 3. Expose Specialist Agents as Tools for the Orchestrator
def run_research_agent(query: str) -> str:
    """Delegates a research task to the ResearchAgent."""
    return research_agent.run(query)

def run_writer_agent(topic: str, notes: str) -> str:
    """Delegates a writing task to the WriterAgent."""
    return writer_agent.run(f"Write a report on {topic} using these notes: {notes}")

orchestrator_tools =

# 4. Create the Orchestrator Agent
orchestrator_agent = FunctionAgent(
    name="Orchestrator",
    tools=orchestrator_tools,
    llm=llm,
    system_prompt="You are a project manager. Your job is to coordinate the research and writing agents to fulfill the user's request. First, use the research agent, then use the writer agent with the research results."
)

# 5. Run the Multi-Agent System
response = orchestrator_agent.run("Create a report on the invention of the web.")
print(response.response)

This implementation follows the orchestrator pattern described in ⁶⁰ and.⁶⁰

Survey of Open-Source Tools

The practice of context engineering is supported by a vibrant open-source ecosystem. These frameworks provide the building blocks for creating, managing, and deploying context-aware AI applications.

Table 4: Key Open-Source Frameworks for Context Engineering

Star counts are approximate as of late 2025. Data synthesized from ⁶, and.⁸³

Real-World Impact: Case Studies in Context Engineering

The adoption of context engineering is not merely a theoretical exercise; it is driving measurable business value across a wide range of industries. The primary driver for this adoption in enterprise settings is often not just incremental performance improvement, but a more fundamental need for risk mitigation. In regulated or high-stakes domains like law, finance, and healthcare, the cost of an ungrounded, hallucinated, or non-compliant AI response can be catastrophic. Context engineering, particularly through RAG, provides the necessary grounding, source attribution, and auditability to make AI systems safe and trustworthy for mission-critical applications.¹⁵

Analysis of Enterprise Adoption

Several organizations have published benchmarks demonstrating the impact of using advanced context engineering components, such as high-performance embedding models, to power their systems.

• Box (Content Intelligence): The intelligent content management platform integrated the Gemini Embedding model to power document question-answering. Their evaluations showed that the system found the correct answer over 81% of the time, representing a 3.6% increase in recall compared to other embedding models. This demonstrates how a superior context retrieval component directly improves the core functionality of the application.⁶⁶
• Everlaw (Legal Discovery): In the legal field, precision is paramount. Everlaw, a platform for verifiable RAG, benchmarked Gemini Embedding and achieved 87% accuracy in surfacing relevant answers from a corpus of 1.4 million complex legal documents, outperforming competing models from Voyage (84%) and OpenAI (73%).⁶⁶
• re:cap (Financial Technology): This company uses embeddings to classify B2B bank transactions. By implementing a more capable embedding model, they measured a direct improvement in their classification F1 score of up to 1.9%, which translates to sharper and more reliable liquidity insights for their customers.⁶⁶
• Mindlid (Mental Wellness): For a personalized AI wellness companion, both relevance and speed are critical. Mindlid leveraged a high-performance embedding model to power its understanding of conversational history, achieving an 82% top-3 recall rate (a 4% lift over a competing model) with a median latency of just 420ms.⁶⁶

Applications Across Industries

The principles of context engineering are being applied to transform core business processes in various sectors:

• Healthcare: AI chatbots for patient engagement are moving beyond generic, scripted responses. By engineering context from Electronic Medical Records (EMRs), wearable device data, and treatment plans, these systems can provide personalized, timely, and clinically relevant advice while enforcing HIPAA compliance through role-based access controls.⁹
• Manufacturing: An AI system for supplier selection can be engineered to integrate real-time context from Enterprise Resource Planning (ERP) systems, supplier portals, and logistics data. This allows the AI to make recommendations based on a holistic understanding of cost, quality, inventory levels, and delivery performance, aligning its suggestions with strategic business goals.⁹
• Finance (BFSI): In loan approval workflows, context engineering enables an AI to access an applicant's credit history, Know Your Customer (KYC) data, and relevant regional regulations. This ensures that its risk assessments are not only accurate but also auditable and compliant with internal policies and external laws.⁹

The Future of Context Engineering and Its Societal Impact

Context engineering is a rapidly evolving discipline that is fundamentally reshaping how we build and interact with AI. Its future trajectory points toward more dynamic, autonomous, and deeply integrated systems, but this progress also brings to the forefront critical research challenges and profound societal and ethical questions.

The Asymmetry of Comprehension vs. Generation: A Critical Research Gap

One of the most significant findings from recent, large-scale academic surveys of the field is the identification of a fundamental asymmetry between an LLM's comprehension and generation capabilities.¹ A comprehensive analysis of over 1,400 research papers, presented in "A Survey of Context Engineering for Large Language Models" (arXiv:2507.13334), reveals that while current models, augmented by advanced context engineering, demonstrate remarkable proficiency in understanding vast and complex contexts, they exhibit pronounced limitations in generating equally sophisticated, coherent, and long-form outputs.⁷⁰

This "comprehension-generation gap" suggests that simply providing more or better context is not a panacea. The ability to ingest and reason over a million tokens of information does not automatically translate into the ability to synthesize that information into a novel, complex artifact of similar length and quality. Addressing this gap—improving the model's generative capabilities to match its impressive comprehension—is identified as a defining priority for the next wave of AI research.¹

Long-Term Vision

The long-term vision for context engineering is a move towards systems that can actively and intelligently manage their own context. Future advancements are likely to include:

• Model-Aware Context Adaptation: Instead of a developer meticulously engineering the context, future models may become capable of dynamically requesting the specific type, format, or granularity of context they need to solve a given problem. The AI would essentially tell the system, "To answer this, I need access to the user's purchase history from the last six months in JSON format".²⁴
• Self-Reflective Agents: The development of agents that can introspect and audit their own context before acting. Such an agent could identify potential for context clash or poisoning, recognize when its retrieved information is insufficient, and flag a high risk of hallucination to a human user before generating a potentially harmful response.²⁴

As these techniques mature, context management will become an increasingly automated and integral part of the AI's own reasoning process, enabling LLMs to tackle ever more sophisticated tasks with greater accuracy and autonomy.⁴⁴

Ethical Considerations

The power to meticulously engineer an AI's "worldview" carries significant ethical responsibilities. As context engineering becomes more sophisticated, it introduces new vectors for harm and manipulation that must be proactively addressed.

• Bias Amplification: The process of selecting, retrieving, and ranking information is not neutral. If the underlying knowledge bases are biased, or if the retrieval and ranking algorithms favor certain types of information, context engineering can systematically amplify and entrench these biases in the AI's outputs. This necessitates a shift from focusing solely on model bias to conducting rigorous fairness audits of the entire context-providing pipeline.⁷³
• The Ethics of Context Manipulation: An expertly engineered context can guide an AI to a specific conclusion. While this is desirable for factual accuracy, it also creates a powerful tool for persuasion and manipulation. The use of context engineering in sensitive domains like political advertising, social media content curation, or news generation raises profound ethical questions. If an AI's context is deliberately curated to exclude dissenting viewpoints or to frame an issue in a particular light, it can become an instrument of sophisticated propaganda. This underscores the critical need for transparency and human oversight in the design of these systems.⁷³
• Transparency and Explainability: As context engineering pipelines become more complex—involving multi-stage retrieval, dynamic summarization, and multi-agent coordination—it becomes increasingly difficult to provide a simple explanation for why an AI generated a particular response.⁷⁷ The final output is the result of a long and dynamic chain of information processing. Ensuring that these systems remain auditable and their reasoning traceable is a major technical and ethical challenge.⁷⁶

The Broader Societal Impact

Ultimately, context engineering should be understood not just as a technical discipline, but as a socio-technical one.⁷⁵ Its practice is fundamentally about creating stable frames of reference that give information its actionable meaning. A historian interpreting primary sources, a lawyer applying legal precedent, and a translator bridging cultural divides are all, in a sense, practicing context engineering.⁷⁵

By formalizing these principles for AI, we are building the infrastructure that will determine how these powerful systems perceive and interact with our world. The challenge is not merely to feed AI better prompts, but to engineer organizational and informational contexts where both AI and humans can develop a shared understanding of reality.⁷⁵ Mastering this discipline will be essential for building the next generation of reliable, personalized, and trustworthy AI that can be safely and beneficially integrated into the core functions of our society.⁶⁷

Conclusion

Context Engineering represents a pivotal maturation in the field of artificial intelligence, marking a definitive shift from the craft of prompt engineering to the architectural science of building intelligent systems. It re-frames the development of AI applications away from a singular focus on the capabilities of the Large Language Model itself, and toward the systematic design of the informational ecosystem in which the model operates. The core insight of this discipline is that the reliability, accuracy, and utility of an AI system are not inherent properties of the model, but emergent properties of the context it is provided.

This report has established a comprehensive framework for understanding this discipline. It began by formally defining Context Engineering and deconstructing the "Context Stack"—the layered set of components including system instructions, memory, retrieved knowledge, and tools that constitute the model's working reality. It then delved into the state-of-the-art techniques that practitioners are using to manage this context, from advanced Retrieval-Augmented Generation strategies like hybrid search and Graph-RAG, to sophisticated methods for managing the context window through compression and pruning.

The analysis of agentic systems, both single and multi-agent, highlights the central role of context in enabling autonomous, multi-step reasoning, while also underscoring the critical importance of security through sandboxing. Through practical code examples and real-world case studies, this report has demonstrated that Context Engineering is not a theoretical abstraction but a practical discipline driving measurable value in enterprise applications, where its ability to mitigate risk and ensure compliance is often as important as its capacity to improve performance.

Looking forward, the field faces significant challenges and profound responsibilities. The "comprehension-generation gap" identified in recent research indicates that there are still fundamental limitations to be overcome in model capabilities. More importantly, the power to engineer an AI's perception of the world brings with it critical ethical imperatives concerning bias, manipulation, and transparency.

The trajectory is clear: as AI becomes more deeply embedded in the fabric of society, the most impactful work will not be in building marginally better models, but in building more robust, reliable, and responsible systems for providing them with context. Context Engineering is the discipline that will guide this work, transforming AI from a powerful but unpredictable tool into a truly intelligent and trustworthy partner.

iKala is a leading AI transformation solutions provider, with a mission to "enable AI competencies" of enterprises by providing AI adoption service and marketing super-intelligence solution, to optimize their operational efficiency and increase customer engagement. iKala's solutions and SaaS products are available in 190+ countries, enabling over 1,000 enterprises and 50,000 brands and advertisers, including top-tier Fortune 500 companies, to transform their business with AI. Contact us for more information.

Works cited

1. arxiv.org, https://arxiv.org/abs/2507.13334
2. Context Engineering: The Evolution Beyond Prompt Engineering That's Revolutionizing AI Agent Development | by Aakash Gupta | Jul, 2025 | Medium, https://medium.com/@aakashgupta/context-engineering-the-evolution-beyond-prompt-engineering-thats-revolutionizing-ai-agent-0dcd57095c50
3. Understanding Context Engineering | by Tamanna | Jul, 2025 …, https://medium.com/@tam.tamanna18/understanding-context-engineering-c7bfeeb41889
4. http://www.analyticsvidhya.com, https://www.analyticsvidhya.com/blog/2025/07/context-engineering/#:~:text=Context%20engineering%20is%20the%20process,exactly%20matches%20the%20required%20output.
5. addyo.substack.com, https://addyo.substack.com/p/context-engineering-bringing-engineering#:~:text=TL%3BDR%3A%20%E2%80%9CContext%20engineering,%2C%20more%20system%2Dlevel%20approach.
6. davidkimai/Context-Engineering: "Context engineering is the delicate art and science of filling the context window with just the right information for the next step." — Andrej Karpathy. A frontier, first-principles handbook inspired by Karpathy and 3Blue1Brown for moving beyond prompt engineering to the wider discipline of context design, orchestration – GitHub, https://github.com/davidkimai/Context-Engineering
7. Context Engineering – LangChain Blog, https://blog.langchain.com/context-engineering-for-agents/
8. Context engineering – Simon Willison's Weblog, https://simonwillison.net/2025/jun/27/context-engineering/
9. Context Engineering | Key components | Tools and Techniques, https://kanerika.com/blogs/context-engineering/
10. Context Engineering: The AI Skill You Should Master in 2025 – Charter Global, https://www.charterglobal.com/context-engineering/
11. Context Engineering vs Prompt Engineering | by Mehul Gupta | Data …, https://medium.com/data-science-in-your-pocket/context-engineering-vs-prompt-engineering-379e9622e19d
12. Context Engineering is the 'New' Prompt Engineering (Learn this Now) – Analytics Vidhya, https://www.analyticsvidhya.com/blog/2025/07/context-engineering/
13. Prompts vs. Context – Drew Breunig, https://www.dbreunig.com/2025/06/25/prompts-vs-context.html
14. Context Engineering: A Guide With Examples – DataCamp, https://www.datacamp.com/blog/context-engineering
15. What is Context Engineering? The New Foundation for Reliable AI and RAG Systems, https://datasciencedojo.com/blog/what-is-context-engineering/
16. Context Engineering: Going Beyond Prompts To Push AI – Simple.AI, https://simple.ai/p/the-skill-thats-replacing-prompt-engineering
17. Context Engineering: Elevating AI Strategy from Prompt Crafting to Enterprise Competence | by Adnan Masood, PhD. | Jun, 2025 | Medium, https://medium.com/@adnanmasood/context-engineering-elevating-ai-strategy-from-prompt-crafting-to-enterprise-competence-b036d3f7f76f
18. Context Engineering Guide, https://www.promptingguide.ai/guides/context-engineering-guide
19. What is Context Engineering for LLMs? | by Tahir | Jul, 2025 | Medium, https://medium.com/@tahirbalarabe2/%EF%B8%8F-what-is-context-engineering-for-llms-90109f856c1c
20. [1hr Talk] Intro to Large Language Models – YouTube, https://www.youtube.com/watch?v=zjkBMFhNj_g
21. Context Engineering – What it is, and techniques to consider …, https://www.llamaindex.ai/blog/context-engineering-what-it-is-and-techniques-to-consider
22. Prompt Engineer vs Context Engineer: Why Design Leadership Needs to See the Bigger Picture | by Elizabeth Eagle-Simbeye | Bootcamp – Medium, https://medium.com/design-bootcamp/prompt-engineer-vs-context-engineer-why-design-leadership-needs-to-see-the-bigger-picture-24eec7ea9a91
23. Context Engineering (1/2)—Getting the best out of Agentic AI Systems | by A B Vijay Kumar, https://abvijaykumar.medium.com/context-engineering-1-2-getting-the-best-out-of-agentic-ai-systems-90e4fe036faf
24. What Is Context Engineering in AI? Techniques, Use Cases, and Why It Matters, https://www.marktechpost.com/2025/07/06/what-is-context-engineering-in-ai-techniques-use-cases-and-why-it-matters/
25. Context Engineering — Simply Explained | by Dr. Nimrita Koul | Jun, 2025 | Medium, https://medium.com/@nimritakoul01/context-engineering-simply-explained-76f6fd1c04ee
26. Short-Term vs. Long-Term LLM Memory: When to Use Prompts vs. Long-Term Recall? – RandomTrees – Blog, https://randomtrees.com/blog/short-term-vs-long-term-llm-memory-prompts-vs-recall/
27. Context Engineering Concepts Part-1: Short-Term Memory | by İlker Genç – Medium, https://medium.com/@ilkergnc00/context-engineering-concepts-part-1-short-term-memory-b97291964056
28. RAG vs Long Context Models [Discussion] : r/MachineLearning – Reddit, https://www.reddit.com/r/MachineLearning/comments/1ax6j73/rag_vs_long_context_models_discussion/
29. Re-Ranking Mechanisms in Retrieval-Augmented Generation Pipelines – Medium, https://medium.com/@adnanmasood/re-ranking-mechanisms-in-retrieval-augmented-generation-pipelines-an-overview-8e24303ee789
30. hub.athina.ai, https://hub.athina.ai/athina-originals/advanced-rag-implementation-using-hybrid-search/
31. Advanced RAG Implementation using Hybrid Search and Reranking | by Nadika Poudel | Medium, https://medium.com/@nadikapoudel16/advanced-rag-implementation-using-hybrid-search-reranking-with-zephyr-alpha-llm-4340b55fef22
32. Advanced RAG Implementation using Hybrid Search: How to Implement it : r/Rag – Reddit, https://www.reddit.com/r/Rag/comments/1i2y1qf/advanced_rag_implementation_using_hybrid_search/
33. Re-ranking in Retrieval Augmented Generation: How to Use Re-rankers in RAG – Chitika, https://www.chitika.com/re-ranking-in-retrieval-augmented-generation-how-to-use-re-rankers-in-rag/
34. Rerankers and Two-Stage Retrieval | Pinecone, https://www.pinecone.io/learn/series/rag/rerankers/
35. Graph RAG: Navigating graphs for Retrieval-Augmented Generation …, https://www.elastic.co/search-labs/blog/rag-graph-traversal
36. What is Graph RAG | Ontotext Fundamentals, https://www.ontotext.com/knowledgehub/fundamentals/what-is-graph-rag/
37. How knowledge graphs take RAG beyond retrieval – QED42, https://www.qed42.com/insights/how-knowledge-graphs-take-rag-beyond-retrieval
38. How to Implement Graph RAG Using Knowledge Graphs and Vector Databases – Medium, https://medium.com/data-science/how-to-implement-graph-rag-using-knowledge-graphs-and-vector-databases-60bb69a22759
39. Introducing Contextual Retrieval \ Anthropic, https://www.anthropic.com/news/contextual-retrieval
40. Context Engineering: Can you trust long context? – Vectara, https://www.vectara.com/blog/context-engineering-can-you-trust-long-context
41. On Context Utilization in Summarization with Large Language Models – arXiv, https://arxiv.org/html/2310.10570v3
42. How to Fix Your Context | Drew Breunig, https://www.dbreunig.com/2025/06/26/how-to-fix-your-context.html
43. Context Engineering — The Hottest Skill in AI Right Now – YouTube, https://www.youtube.com/watch?v=ioOHXt7wjhM
44. What is Context Engineering? The Future of AI Optimization Explained – Geeky Gadgets, https://www.geeky-gadgets.com/why-context-engineering-is-the-future-of-artificial-intelligence/
45. Compressing Context to Enhance Inference Efficiency of Large …, https://aclanthology.org/2023.emnlp-main.391/
46. Prompt Compression with Context-Aware Sentence Encoding for …, https://ojs.aaai.org/index.php/AAAI/article/view/34639/36794
47. Recurrent Context Compression: Efficiently Expanding the Context …, https://openreview.net/forum?id=GYk0thSY1M
48. Provence: efficient and robust context pruning for retrieval …, https://huggingface.co/blog/nadiinchi/provence
49. Stop Overfeeding Your LLM: Smart Context Pruning with Provence | by kirouane Ayoub | Jul, 2025 | Medium, https://medium.com/@ayoubkirouane3/stop-overfeeding-your-llm-smart-context-pruning-with-provence-3b42dcb06f4e
50. Has anyone tried context pruning ? : r/Rag – Reddit, https://www.reddit.com/r/Rag/comments/1m4ogm4/has_anyone_tried_context_pruning/
51. Master LLM Summarization Strategies and their Implementations – Galileo AI, https://galileo.ai/blog/llm-summarization-strategies
52. LaMSUM: Creating Extractive Summaries of User Generated Content using LLMs – arXiv, https://arxiv.org/html/2406.15809v2
53. A Step-By-Step Guide to Evaluating an LLM Text Summarization Task – Confident AI, https://www.confident-ai.com/blog/a-step-by-step-guide-to-evaluating-an-llm-text-summarization-task
54. What Are AI Agents? | IBM, https://www.ibm.com/think/topics/ai-agents
55. Build an Agent | 🦜️ LangChain, https://python.langchain.com/docs/tutorials/agents/
56. A Comprehensive Guide to Context Engineering for AI Agents | by Tamanna – Medium, https://medium.com/@tam.tamanna18/a-comprehensive-guide-to-context-engineering-for-ai-agents-80c86e075fc1
57. How and when to build multi-agent systems – LangChain Blog, https://blog.langchain.com/how-and-when-to-build-multi-agent-systems/
58. How we built our multi-agent research system \ Anthropic, https://www.anthropic.com/engineering/built-multi-agent-research-system
59. Why 'Context Engineering' is the New Frontier for AI Agents – Vellum AI, https://www.vellum.ai/blog/context-is-king-why-context-engineering-is-the-new-frontier-for-ai-agents
60. Multi-agent workflows – LlamaIndex, https://docs.llamaindex.ai/en/stable/understanding/agent/multi_agent/
61. Context Engineering for Multi-Agent AI Workflows – DataOps Labs, https://blog.dataopslabs.com/context-engineering-for-multi-agent-ai-workflows
62. LangGraph – LangChain, https://www.langchain.com/langgraph
63. Inadequate Sandboxing in LLMs — OWASP LLM Top 10 | by …, https://medium.com/@akanksha.amarendra6/inadequate-sandboxing-in-llms-owasp-llm-top-10-45be4c88c402
64. vndee/llm-sandbox: Lightweight and portable LLM sandbox … – GitHub, https://github.com/vndee/llm-sandbox
65. SandboxEval: Towards Securing Test Environment for Untrusted Code – arXiv, https://arxiv.org/html/2504.00018v1
66. Gemini Embedding: Powering RAG and context engineering – Google Developers Blog, https://developers.googleblog.com/en/gemini-embedding-powering-rag-context-engineering/
67. Context Engineering: The Future of AI Development – Voiceflow, https://www.voiceflow.com/blog/context-engineering
68. A Survey of Context Engineering for Large Language Models – ResearchGate, https://www.researchgate.net/publication/393783866_A_Survey_of_Context_Engineering_for_Large_Language_Models
69. A Survey of Context Engineering for Large Language Models | AI Research Paper Details, https://www.aimodels.fyi/papers/arxiv/survey-context-engineering-large-language-models
70. Paper page – A Survey of Context Engineering for Large Language Models – Hugging Face, https://huggingface.co/papers/2507.13334
71. A Survey of Context Engineering for Large Language Models – Paper Detail, https://deeplearn.org/arxiv/621918/a-survey-of-context-engineering-for-large-language-models
72. A Survey of Context Engineering for Large Language Models | Latest Papers, https://hyper.ai/en/papers/2507.13334
73. What Is AI ethics? The role of ethics in AI – SAP, https://www.sap.com/resources/what-is-ai-ethics
74. Biases – Prompt Engineering Guide, https://www.promptingguide.ai/risks/biases
75. Everyone is Talking About Context Engineering | by Inspired Nonsense | Jul, 2025 | Medium, https://inspirednonsense.com/everyone-is-talking-about-context-engineering-d5e19fa030db
76. Ethics of Artificial Intelligence | UNESCO, https://www.unesco.org/en/artificial-intelligence/recommendation-ethics
77. What is Context Engineering: Clearly Explained – Apidog, https://apidog.com/blog/context-engineering/
78. Incorporating the Impact of Engineering Solutions on Society into Technical Engineering Courses, https://cmbe.engr.uga.edu/ABET/Articles/Impact%20of%20Engineering%20Solutions%20on%20Society.pdf
79. A Long-Term Memory Agent | 🦜️ LangChain, https://python.langchain.com/docs/versions/migrating_memory/long_term_memory_agent/
80. context-engineering · GitHub Topics, https://github.com/topics/context-engineering?l=python
81. The 10 Best Context Engineering Open Source Projects in 2025 – DEV Community, https://dev.to/contextspace_/the-10-best-context-engineering-open-source-projects-in-2025-4f94
82. multiagent-systems · GitHub Topics, https://github.com/topics/multiagent-systems
83. kingjulio8238/Memary: The Open Source Memory Layer For Autonomous Agents – GitHub, https://github.com/kingjulio8238/Memary