Context Engineering: The New Frontier in Agentic AI

Reading Time: 13 minutes

Level: Intermediate-Advanced

Picture this: You’ve built an AI customer support agent. You’ve fed it your entire documentation—all 5,000 pages of it. Your product catalog, FAQs, troubleshooting guides, everything. The model is top-notch—GPT-5, latest Claude opus or sonnet, you name it. Yet when a customer asks a straightforward question about your refund policy, the agent fumbles. It gives outdated information. It misses the crucial detail buried on page 2,847.

The problem? It’s not the model. It’s the context.

Welcome to 2025-2026, where we’re witnessing a fundamental shift in how we build AI systems. The era of obsessing over the perfect prompt is fading. We’re entering the age of context engineering—and it’s changing everything.

The Great Shift: From Prompts to Context

For years, we’ve been playing the prompt engineering game. Craft the perfect instruction. Add the right examples. Use the magic phrase “Let’s think step by step.” And honestly, it worked—for simple demos and prototypes.

But something changed in 2025. As AI agents moved from exciting demos to production systems handling millions of real-world interactions, we hit a wall. Not a model capability wall—a context wall.

Here’s the reality check: Most AI agent failures today aren’t because the model is dumb. They’re because the model doesn’t have the right information at the right time.

Think about it like this: Your LLM’s context window is like RAM in a computer. You can have the world’s most powerful processor (the model), but if your RAM is poorly managed—filled with irrelevant data, missing crucial bits, or organized chaotically—your system will struggle. Context engineering is the discipline of managing that RAM brilliantly.

And the industry agrees. Anthropic, Google, OpenAI—everyone’s talking about it. In November 2024, Anthropic even released the Model Context Protocol (MCP), calling it “USB-C for AI.” In December 2025, they donated it to the Linux Foundation. That’s how big this is.

So What Exactly IS Context Engineering?

Let’s get clear on this. Context engineering is the systematic design and management of all the information you provide to an AI system. It goes way beyond just writing a good prompt.

When you do prompt engineering, you’re crafting a single instruction: “Summarize this document in 3 bullet points.” That’s it. One request, one response.

When you do context engineering, you’re architecting an entire information environment:

System instructions (Who is this AI? What rules should it follow?)
Conversation history (What have we discussed already?)
Retrieved knowledge (What documents, data, or facts are relevant right now?)
Tool schemas (What actions can the AI take?)
Dynamic state (What’s the current task? User preferences? Environment variables?)

It’s the difference between handing someone a question and building them an entire workspace with all the resources they need to excel.

Why the Evolution?

The shift happened because of three converging forces:

1. Rising Expectations Users don’t want chatbots that forget their last message. They want AI that remembers their preferences, learns from feedback, and provides personalized experiences. That requires sophisticated context management.

2. Enterprise Adoption Companies deploying AI at scale need reliability, accuracy, and consistency across millions of interactions. You can’t achieve that with ad-hoc prompting. You need systematic context engineering.

3. Advanced Models Modern LLMs can handle 128K, 200K, even 2 million tokens of context. But here’s the kicker: research shows they only effectively use 10-20% of very long contexts. Having a giant context window doesn’t mean much if you don’t engineer what goes into it.

The Anatomy of Context: What Actually Goes In?

Let’s dissect what makes up “context” in a modern AI system. Imagine you’re building that customer support agent we mentioned earlier. Here’s what the agent needs to “see” in its context window for each interaction:

1. System Instructions

The foundation layer. This tells the AI who it is and how to behave:

“You are a helpful customer support agent for TechCorp”
“Always be polite, concise, and verify information before providing it”
“Format responses using bullet points for clarity”

2. Conversation History

What’s been said so far in this specific conversation:

User: “Hi, I need help with my recent order”
Agent: “I’d be happy to help! Could you provide your order number?”
User: “It’s #TC-90210”

3. Retrieved Knowledge

Information pulled from external sources based on the current query:

Customer’s order details from the database
Relevant sections from the refund policy
Similar past support tickets for reference

4. Tool Schemas and Outputs

What actions the agent can take and what it’s already done:

Available tools: check_order_status(), initiate_refund(), send_email()
Previous tool results: Order status returned → “Shipped on Jan 30”

5. Dynamic State

Real-time information:

Customer tier: Premium (gets expedited support)
Current agent workload: High (keep responses concise)
User’s timezone: EST (respond during business hours)

Now here’s the challenge: Let’s say your refund policy is 1,000 pages, customer history has 500 past interactions, product docs are 5,000 pages, and you’re having a 50-message conversation. That’s potentially 10 million tokens. Your context window? Maybe 128,000 tokens.

You need to fit a library into a backpack. That’s context engineering.

Memory Systems: The Backbone of Great Context

If context is like RAM, memory is like your hard drive and cache combined. Modern AI agents need both short-term and long-term memory to function effectively.

Short-Term Memory: The Conversation Buffer

This is your working memory for the current session. When someone’s chatting with your agent, it needs to remember what was said 5 minutes ago.

How it works:

Buffer Memory: Store everything verbatim. Great for short conversations, but expensive for long ones.
Window Memory: Keep only the last K interactions. Perfect for maintaining recent context without bloat.
Summary Memory: Use the LLM itself to summarize older parts of the conversation. Keeps the gist while reducing tokens.

In Practice (LangChain):

from langchain.memory import ConversationBufferWindowMemory

# Keep only the last 5 exchanges
memory = ConversationBufferWindowMemory(k=5)

Think of it like your WhatsApp chat. You don’t need to reread the entire 3-year conversation history to reply to the latest message. Just the recent context suffices.

Long-Term Memory: Persistent Knowledge

This is where things get powerful. Long-term memory persists across sessions. The agent remembers facts, preferences, and decisions from weeks or months ago.

The Secret Sauce: Vector Databases

Instead of storing text directly, you convert information into numerical vectors (embeddings) and store them in specialized databases like Pinecone, Milvus, or Weaviate. When you need to recall something, you search semantically—by meaning, not just keywords.

Example:

User says: “I prefer minimalist designs”
Stored as vector in long-term memory
Two weeks later, user asks for design recommendations
Agent recalls: “Based on your preference for minimalist designs…”

It’s the difference between Ctrl+F (keyword search) and having a conversation with someone who truly understands what you mean.

Episodic vs. Semantic Memory

Borrowing from cognitive science, AI agents benefit from two types of memory:

Episodic Memory = Specific events with context “I booked a flight to Mumbai for User X on January 15th because they were attending a conference.”

Semantic Memory = General factual knowledge “Mumbai is the financial capital of India.”

Together, they provide depth (episodic details) and breadth (general knowledge). Episodic memory is typically stored in time-indexed logs or graphs. Semantic memory lives in knowledge bases and vector embeddings.

RAG: The Bridge Between Memory and Context

Retrieval-Augmented Generation (RAG) is where long-term memory meets real-time context.

Traditional Approach: Cram all knowledge into the model’s training. Problem: Knowledge gets outdated, hallucinations increase, can’t scale.

RAG Approach:

Store vast amounts of information externally (in vector DBs, knowledge bases)
When a query comes in, retrieve only the most relevant pieces
Inject that focused information into the context window
Generate response based on fresh, targeted data

What’s New in 2024-2025:

Agentic RAG: Multiple retrieval steps throughout a task, not just one at the start
Memory-Augmented RAG: The system learns from past retrievals, adapting what to fetch
Editable Memory Graphs: Special structures that optimize memory selection using reinforcement learning

RAG lets you have your cake and eat it too: Massive knowledge bases + Focused, efficient context.

The “Lost in the Middle” Problem (And How to Fix It)

Here’s a dirty secret about large context windows: LLMs have terrible memory for information in the middle.

Research revealed a “U-shaped” performance curve. Models pay strong attention to information at the beginning and end of context, but the middle? It’s like the middle child—often overlooked.

Even Claude with its 200K token window or GPT-4 with 128K suffers from this. Your crucial piece of information buried on page 47 of a 100-page context? Good luck.

Solutions That Actually Work

1. Strategic Reranking Don’t just dump documents into context in random order. Use reranking models to place the most critical information at the start or end.

2. In-Context Retrieval (ICR) A clever two-step approach:

Step 1: Ask the LLM to identify which passage numbers are relevant to the query
Step 2: Extract just those passages and use them for the final answer
Result: Reduced context length, laser-focused attention

3. Chunking and Compress ing Break massive documents into smaller pieces. Process each piece separately. Summarize or compress aggressively. You’d be surprised—smart filtering can reduce tokens by 70-90% without losing critical information.

4. Prompt Compression Tools like Microsoft’s LLMLingua automatically remove redundant words while preserving meaning. “The customer is extremely dissatisfied with the delayed delivery” becomes “Customer dissatisfied, delayed delivery.” Same info, fewer tokens.

5. Architectural Innovation Newer techniques like Rotary Position Embeddings (RoPE), sparse attention patterns (Longformer, BigBird), and state-space models (Mamba) are making models better at handling long contexts. But even with these, strategic engineering matters.

Key Takeaway: A bigger context window is like a bigger suitcase. Sure, you can fit more stuff. But if you don’t pack smartly, you’re still going to struggle to find your toothbrush.

Multi-Agent Systems: Distributed Context Intelligence

Here’s where context engineering gets really interesting. Instead of one mega-agent trying to juggle everything, what if you had a team of specialized agents, each with its own focused context?

Why Go Multi-Agent?

1. Prevent Context Overflow One agent researching + analyzing + writing + editing = context chaos. Separate agents for research, analysis, and writing = Each has a clean, focused context.

2. Specialization A research agent doesn’t need to know how to format markdown. A writing agent doesn’t need access to database schemas. Give each agent only what it needs.

3. Parallel Processing Multiple agents can work simultaneously on different aspects of a task.

In LangGraph (a framework for multi-agent systems), agents communicate through a shared state—think of it as a collaborative whiteboard.

How it works:

Research Agent finds relevant information → Writes to shared state
Analysis Agent reads findings → Adds insights to shared state
Writing Agent reads everything → Produces final output

Each agent has its own specialized context (tools, prompts), but they all contribute to and read from a central state. It’s like a relay race where the baton (state) carries all completed work.

Context Handoff: The Supervisor Pattern

Another common architecture: A Supervisor agent orchestrates multiple worker agents.

Flow:

User Query
    ↓
Supervisor (decides which agent to call)
    ↓
Worker Agent A (processes, updates context)
    ↓
Supervisor (synthesizes, decides next  step)
    ↓
Worker Agent B (continues with clean context)
    ↓
Supervisor (final response)

Each worker hands off a cleanly packaged context to the next. No clutter, no confusion.

The Model Context Protocol (MCP): Standardizing the Handoff

In November 2024, Anthropic introduced MCP—a game-changer for context engineering.

The Problem: Every AI framework had its own way of managing context. Integrating data sources required custom connectors for each combination. It was messy.

The Solution: MCP standardizes how AI systems connect to data sources and share context. Think of it as USB-C for AI—one protocol, universal compatibility.

Three Core Primitives:

Tools: Functions the AI can execute (e.g., query_database())
Resources: Data sources for context (e.g., documents, APIs)
Prompts: Reusable templates for interaction patterns

By December 2025, Anthropic donated MCP to the Linux Foundation, signaling a commitment to industry-wide adoption. It’s early days, but MCP could become the standard for context exchange between agents.

Prompt Engineering in the Context Era

So does prompt engineering still matter? Absolutely—but it’s evolved.

Context Injection: Dynamic Knowledge

Modern prompts aren’t static. They’re templates with placeholders that get filled dynamically:

System: You are an expert {role}
Context: {retrieved_documents}
User History: {past_interactions}
Current Query: {user_question}
Output Format: {desired_format}

When a query comes in, the system:

Retrieves relevant documents based on the query
Fetches user history from long-term memory
Injects everything into the template
Sends to the LLM

This is context-aware prompting—prompts that adapt based on what’s relevant right now.

Advanced Techniques (2024 Edition)

Chain-of-Thought with Memory Break complex tasks into steps, each step accessing relevant parts of memory. Cumulative reasoning gets better with context.

Few-Shot with Context Don’t just provide examples—provide examples with their contexts. The LLM learns not just the pattern, but also how to use context effectively.

Meta-Prompting Instead of relying on examples, structure the format and logic of the response. Guide the LLM on how to think through problems using available context.

Self-Consistency Generate multiple reasoning paths using the same context, then pick the most consistent answer. Works great when context is rich and reliable.

The shift: From “write better prompts” to “architect better context that makes any reasonable prompt work well.”

Cost Optimization: The 90% Savings Opportunity

Let’s talk money. If you’re running AI agents at scale, context engineering isn’t just about performance—it’s about survival.

The Problem

LLMs charge by the token. More context = More tokens = Higher costs. A customer support agent handling 5,000 conversations daily, each with a 10,000-token context, is processing 50 million tokens a day. At $0.01 per 1K tokens (rough average), that’s $500/day, or $15,000/month.

The Solution: Context Caching

How it works: Identify the static parts of your context (system instructions, company policies, product docs) and cache them on the server side. You only pay the full price once. After that, you pay a tiny fraction (often 10% or less) for cache hits.

Example (Claude’s Prompt Caching):

First request: 10,000 tokens (system + docs) = $0.10
Next 99 requests: Only the new user query (100 tokens) + cache hit discount = $0.001 each
Savings: 90% on input costs

Impact on Latency: Cached contexts don’t need to be “read” again by the model. This can reduce latency by up to 80%. Faster responses and lower costs.

Agentic Plan Caching

A newer technique: Cache entire agent plans, not just prompts. For “Plan-Act” agents that coordinate multiple steps, caching the plan at the task level (instead of query level) has shown 47% cost reductions in research.

Other Cost Strategies

1. Right-Size Your Models Don’t use GPT-4 for every task. Use smaller, cheaper models (GPT-3.5, Claude Haiku) for simple routing or summarization. Reserve expensive models for complex reasoning.

2. Compress Before Processing Summarize long documents before feeding to the agent. Hierarchical summarization can turn a 50,000-token document into a 500-token summary.

3. Trim Conversation History Don’t let conversations grow unbounded. Keep the last N messages, or summarize older parts.

4. Smart Filtering Extract only the relevant sections from documents. If a user asks about refunds, pull the refund section—not the entire 1,000-page policy.

Real ROI Example:

Before Context Engineering:
- 5,000 conversations/day
- 10,000 tokens/conversation
- 50M tokens/day × $0.01/1K = $500/day = $15,000/month

After (caching + compression + filtering):
- Same 5,000 conversations
- Cached static context (90% discount)
- Compressed dynamic context (70% reduction)
- 5M tokens/day × $0.01/1K = $50/day = $1,500/month

Savings: $13,500/month (90%)

That’s hiring a full-time engineer to optimize context—and they pay for themselves in a week.

Practical Tools: Your Context Engineering Toolkit

Enough theory. Let’s talk frameworks.

LangChain: The Orchestrator

Best for: Conversational agents, RAG applications, chains of reasoning

Key Features:

Memory Modules:
- ConversationBufferMemory: Full verbatim history
- ConversationSummaryMemory: LLM-generated summaries
- ConversationKnowledgeGraphMemory: Extract entities and relationships
- VectorStoreRetrieverMemory: Semantic search from vector DBs
LCEL (LangChain Expression Language): Compose complex chains where context flows smoothly from step to step

When to use: You’re building chatbots, Q&A systems, or anything that needs conversational memory.

LangGraph: The Multi-Agent Maestro

Best for: Complex workflows, multi-agent systems, stateful applications

Key Features:

Shared State Management: Central memory accessible to all agents
Checkpointers: Persist state to PostgreSQL, Redis, SQLite—resume from failures
Supervisor Patterns: Built-in support for orchestrating specialized agents
Durable Execution: Long-running tasks that survive crashes

When to use: Your task requires multiple steps, multiple agents, or needs to survive interruptions.

LlamaIndex: The Context Specialist

Best for: Document-centric apps, knowledge base integration, advanced indexing

Key Features:

Context Engine: ContextChatEngine retrieves relevant text and injects it as system context
Memory Class: Combines short-term (FIFO queue) and long-term memory (static, fact extraction, vector blocks)
Agent Workflows: Define step-by-step sequences to prevent context overload
Efficient Indexing: Chunking, incremental processing, compressed embeddings for memory optimization

When to use: You’re working with large document collections and need sophisticated retrieval.

Quick Decision Matrix

Framework	Strength	Use When…
LangChain	Orchestration, memory modules	Building conversational flows
LangGraph	Multi-agent, state management	Complex workflows, multiple specialized agents
LlamaIndex	Document indexing, retrieval	Knowledge-intensive applications

Pro Tip: These tools aren’t mutually exclusive. A common pattern: Use LlamaIndex for indexing and retrieval, then feed the results into LangChain or LangGraph for orchestration.

Best Practices: Do’s and Don’ts

Do’s

1. Prioritize Relevance Over Quantity More context isn’t always better. Aim for “just the right information.” Keep context usage at 80-85% of the max limit—leave some headroom.

2. Structure Your Context Clearly Use clear delimiters and sections:

=== SYSTEM INSTRUCTIONS ===
...
=== CONVERSATION HISTORY ===
...
=== RETRIEVED KNOWLEDGE ===
...
=== CURRENT QUERY ===
...

3. Implement Hierarchical Memory

Core memory: Critical facts, always present
Extended memory: Retrieved on-demand
Archived memory: Long-term storage, rarely accessed

4. Monitor Context Usage Set up dashboards to track token consumption, context bloat, and performance degradation. Catch issues before they become expensive.

5. Test at the Limits Deliberately test with maximum context lengths. Check for “lost in the middle” issues. Validate before going to production.

Don’ts

1. Don’t Stuff the Context Context rot is real. Overloading leads to degraded performance. Quality beats quantity.

2. Don’t Ignore Position Critical information should be at the start or end of context. Never bury important details in the middle.

3. Don’t Forget to Prune Old conversations accumulate. Without pruning, you’ll hit limits and performance will tank. Implement automatic cleanup.

4. Don’t Skip Caching Static, repetitive content (system prompts, documentation) should always be cached. It’s free money.

5. Don’t Mix Agent Contexts In multi-agent systems, keep contexts isolated. Prevent cross-contamination. Use explicit handoff protocols.

Real-World Impact: Context Engineering in Action

Case Study 1: Anthropic’s Multi-Agent Research System

Challenge: Build an AI system that can conduct research spanning days, with tasks requiring 100+ steps.

Context Problems:

Context windows fill up quickly
Need continuity across multiple work phases
Can’t lose track of earlier findings

Solution:

Summarize each completed research phase
Store essential information in external memory
Spawn fresh subagents with clean contexts for new phases
Retrieve phase summaries when needed

Result: Successfully handle multi-day research tasks with coherent outputs despite tight context constraints.

Case Study 2: Enterprise Customer Support

Scenario: Global tech company, 10,000 daily support interactions

Before Context Engineering:

Inconsistent responses (agents couldn’t recall past decisions)
High latency (re-processing same documents repeatedly)
$50,000/month in LLM costs

After:

Prompt caching for company policies and guidelines
Vector database for customer interaction history
Multi-agent system: Triage → Specialist → Resolution
Clear context handoff protocols

Results:

85% cost reduction: Down to $7,500/month
80% latency improvement: Faster responses
40% accuracy boost: Better resolution rates

ROI: Paid for the engineering effort in 2 weeks.

Case Study 3: Code Assistant (Copilot-Style)

Context Challenges:

Entire codebase as potential context
Users frequently access the same files
Need to track user patterns and preferences

Engineering Approach:

Explicit caching for frequently accessed files (90% cost savings)
Semantic code search using embeddings
Incremental context: Only include changed files, not entire codebase
User-specific memory: Track preferred patterns and libraries

Impact:

Near-instant code suggestions (cached contexts load fast)
Codebase-aware completions (knows the architecture)
90% reduction in token costs (aggressive caching and filtering)

The Future: What’s Coming Next

Trends for 2025-2026

1. Memory-First Architectures Future agents will prioritize their internal memory and only reach for external retrieval when necessary. Smarter, more autonomous systems.

2. Adaptive Context Management AI systems that automatically select and prioritize context based on task complexity. Self-optimizing context windows.

3. MCP Ecosystem Growth As more tools adopt the Model Context Protocol, plug-and-play context integration becomes the norm. Standardization wins.

4. Hybrid Memory Strategies Combining long-term memory systems with ultra-large context windows. Best of both worlds—deep history + immediate access.

5. Cost-Aware Context Engineering Built-in optimization where the system automatically makes caching decisions based on cost budgets. Financial constraints drive architectural choices.

Emerging Challenges

1. Context SecurityAs contexts grow richer, they become targets:

Context poisoning attacks (injecting malicious info)
Sensitive data leakage
Need for context-level encryption and isolation

2. Context GovernanceCompliance requirements hit context:

GDPR data retention in memory systems
Audit trails for context changes
Explainability: “Why did the agent see this piece of information?”

3. Coflicting Contexts What happens when retrieved documents contradict each other? Source attribution and truth grounding become critical.

Skills You Need to Master

For AI Engineers:

MCP protocol implementation
Vector database optimization and tuning
Multi-agent orchestration and state management
Cost modeling for context-heavy workloads
Context monitoring and observability

Mindset Shifts:

From “write better prompts” → “architect better context”
From single-turn interactions → multi-turn, multi-agent workflows
From model-centric → information-centric systems

The engineers who master context engineering will build the AI systems that actually work in production—at scale, reliably, and cost-effectively.

Wrapping Up: Context is King

We started with a simple observation: AI systems fail not because models are inadequate, but because they lack the right context.

Here’s what we’ve learned:

Context engineering is the new frontier—it’s evolved beyond prompt engineering to full information architecture
Memory systems are fundamental—short-term + long-term, episodic + semantic
Bigger context windows ≠ better performance—the “lost in the middle” problem is real
Multi-agent architectures distribute context intelligently—specialization wins
Cost optimization is huge—90% savings with caching and compression
Tools are maturing fast—LangChain, LangGraph, LlamaIndex make it accessible

But here’s the deeper insight: The AI revolution isn’t just about better models. It’s about better ways of organizing and delivering information.

The companies winning with AI aren’t necessarily those with the best GPUs or the largest training budgets. They’re the ones who’ve mastered the art and science of context engineering.

Your Action Plan

This Week:

Audit your current AI system’s context usage (What’s going in? What’s being wasted?)
Implement prompt caching if you haven’t already (Easiest 90% savings you’ll ever get)
Check for “lost in the middle” problems in your long-context prompts

This Month:

Set up a vector database for long-term memory
Experiment with LangGraph for multi-agent workflows
Establish metrics: Context token usage, cache hit rates, cost per interaction

This Quarter:

Adopt MCP for standardized data integrations
Build production-grade memory systems
Train your team on context engineering principles

In 2025, we learned a crucial lesson: The best AI systems aren’t those with the cleverest prompts or the most powerful models. They’re the ones that architect context brilliantly.

Master context engineering, and you won’t just build AI that works—you’ll build AI that excels.

Now go forth and engineer some brilliant contexts. Your LLM’s RAM is waiting.

Further Reading:

About This Article Research conducted: February 2026 Sources: 16 authoritative references (official documentation, academic papers, technical blogs) All insights based on 2024-2025 developments in AI systems

Context Engineering: The New Frontier in Agentic AI

The Great Shift: From Prompts to Context

So What Exactly IS Context Engineering?

Why the Evolution?

The Anatomy of Context: What Actually Goes In?

1. System Instructions

2. Conversation History

3. Retrieved Knowledge

4. Tool Schemas and Outputs

5. Dynamic State

Memory Systems: The Backbone of Great Context

Short-Term Memory: The Conversation Buffer

Long-Term Memory: Persistent Knowledge

Episodic vs. Semantic Memory

RAG: The Bridge Between Memory and Context

The “Lost in the Middle” Problem (And How to Fix It)

Solutions That Actually Work

Multi-Agent Systems: Distributed Context Intelligence

Why Go Multi-Agent?

Context Sharing: The Shared State Pattern

Context Handoff: The Supervisor Pattern

The Model Context Protocol (MCP): Standardizing the Handoff

Prompt Engineering in the Context Era

Context Injection: Dynamic Knowledge

Advanced Techniques (2024 Edition)

Cost Optimization: The 90% Savings Opportunity

The Problem

The Solution: Context Caching

Agentic Plan Caching

Other Cost Strategies

Practical Tools: Your Context Engineering Toolkit

LangChain: The Orchestrator

LangGraph: The Multi-Agent Maestro

LlamaIndex: The Context Specialist

Quick Decision Matrix

Best Practices: Do’s and Don’ts

Do’s

Don’ts

Real-World Impact: Context Engineering in Action

Case Study 1: Anthropic’s Multi-Agent Research System

Case Study 2: Enterprise Customer Support

Case Study 3: Code Assistant (Copilot-Style)

The Future: What’s Coming Next

Trends for 2025-2026

Emerging Challenges

Skills You Need to Master

Wrapping Up: Context is King

Your Action Plan