>FOUNDRY_AI
FOUNDRY AI.KB
v2.2.0 // CONTEXT ENGINEERING
Overview
Root Cause
Core Strategies
Platforms
Architectures
Implementation
Best Practices

05 SOLUTION ARCHITECTURES

Production-ready patterns for consistent agent systems.

Use Case 1: Consistent Website Styling

Problem: Agent generates inconsistent UI components across sessions, forgetting established design system rules.

Solution Architecture

┌─────────────────────────────────────────────────────────┐
│                     System Prompt                        │
│  • Design system rules (colors, spacing, components)    │
│  • Component naming conventions                          │
│  • Accessibility requirements                            │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                    Tool Integration                      │
│  • getComponentLibrary(): Fetch available components    │
│  • validateDesign(code): Check against design system    │
│  • getPreviousComponents(): Retrieve past generations   │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                   State Management                       │
│  • Track generated components in database               │
│  • Store design decisions and rationale                 │
│  • Maintain component dependency graph                  │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                     Validation Layer                     │
│  • Pre-delivery code review against design system       │
│  • Automated accessibility checks                       │
│  • Consistency scoring vs. existing components          │
└─────────────────────────────────────────────────────────┘

Platform Implementation

Claude:

  • Use Projects to store design system documentation
  • Reference design tokens in each conversation
  • Implement custom validation tools

Manus:

  • Create custom tools for component lookup
  • Persist design decisions across sessions
  • Leverage built-in state management

OpenAI:

  • Upload design system to Assistant's vector store
  • Query during generation for relevant patterns
  • Use function calling for validation

Use Case 2: Multi-Step Data Analysis

Problem: Agent loses track of analysis progress, repeats steps, or contradicts earlier findings.

Solution Architecture

┌─────────────────────────────────────────────────────────┐
│                  Analysis State Machine                  │
│  States: [data_loading, exploration, hypothesis,        │
│           validation, visualization, reporting]          │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                   Episodic Memory                        │
│  • Save checkpoint after each major step                │
│  • Store: findings, decisions, intermediate results     │
│  • Enable rollback to previous analysis states          │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                    RAG for Data Access                   │
│  • Retrieve relevant data subsets (not entire dataset)  │
│  • Semantic search over previous findings               │
│  • Query historical analysis for similar patterns       │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                   Structured Output                      │
│  • Enforce consistent data format across steps          │
│  • JSON schema validation for results                   │
│  • Standardized visualization specifications            │
└─────────────────────────────────────────────────────────┘

Key Components

  1. Progress Tracking: Explicit state machine prevents repeated work
  2. Checkpointing: Save analysis state after each major step
  3. Selective Retrieval: Load only relevant data subsets
  4. Consistency Enforcement: Structured outputs prevent format drift

Use Case 3: Customer Support with Personalization

Problem: Agent doesn't remember customer preferences or previous interactions.

Solution Architecture

┌─────────────────────────────────────────────────────────┐
│                  Long-term Memory Store                  │
│  • Customer profile (preferences, tier, history)        │
│  • Interaction summaries (not full transcripts)         │
│  • Resolution patterns and outcomes                      │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                   Context Selection                      │
│  • Retrieve only relevant past interactions             │
│  • Prioritize recent + high-impact interactions         │
│  • Include customer preferences and constraints          │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                    Summarization Layer                   │
│  • Compress lengthy support threads into key facts      │
│  • Extract: issue, resolution, customer sentiment       │
│  • Maintain decision rationale                          │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                     Tool Access Layer                    │
│  • queryCRM(customerId): Get customer data              │
│  • searchKnowledgeBase(query): Find solutions           │
│  • getOrderHistory(customerId): Retrieve orders         │
│  • createTicket(issue): Escalate to human              │
└─────────────────────────────────────────────────────────┘

Implementation Details

Memory Strategy:

  • Store customer profile in structured database
  • Summarize interactions after each session
  • Retrieve top-K relevant interactions based on current query

Context Budget:

  • Customer profile: 2K tokens
  • Recent interactions: 8K tokens
  • Knowledge base results: 12K tokens
  • System prompt: 4K tokens
  • Working memory: 10K tokens

Architecture Pattern: The Context Engineering Stack

A generalized architecture for production AI agents:

┌─────────────────────────────────────────────────────────┐
│                     Application Layer                    │
│              (User Interface, API Endpoints)             │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                   Orchestration Layer                    │
│  • Request routing                                       │
│  • Context assembly                                      │
│  • Response streaming                                    │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                    Context Management                    │
│  • Memory retrieval        • State tracking             │
│  • Context budgeting       • Summarization              │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                      LLM Provider                        │
│         (Claude, OpenAI, Manus, or Custom)              │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                      Tool Execution                      │
│  • External APIs          • Database queries            │
│  • Code execution         • File operations             │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                    Persistence Layer                     │
│  • Vector database        • Relational database         │
│  • Object storage         • Cache layer                 │
└─────────────────────────────────────────────────────────┘

Layer Responsibilities

Application Layer:

  • Handle user requests and responses
  • Manage authentication and authorization
  • Provide observability and monitoring

Orchestration Layer:

  • Assemble context from multiple sources
  • Route requests to appropriate handlers
  • Stream responses to users

Context Management:

  • Retrieve relevant memories
  • Track conversation state
  • Enforce context budgets
  • Trigger summarization

LLM Provider:

  • Generate responses
  • Execute tool calls
  • Maintain conversation thread

Tool Execution:

  • Provide agent capabilities
  • Access external systems
  • Return structured results

Persistence Layer:

  • Store long-term memories
  • Maintain vector embeddings
  • Cache frequent queries

Best Practices for Production Architectures

1. Separation of Concerns

Don't mix context management logic with business logic. Keep them in separate, well-defined layers.

2. Observability

Instrument every layer:

  • Log context assembly decisions
  • Track token usage per component
  • Monitor retrieval relevance scores
  • Measure end-to-end latency

3. Graceful Degradation

When context budget is exceeded:

  • Prioritize critical information
  • Summarize aggressively
  • Fail gracefully with user notification

4. Testing Strategy

  • Unit tests: Individual context management functions
  • Integration tests: Full context assembly pipeline
  • End-to-end tests: Agent behavior across sessions
  • Load tests: Performance under context pressure

5. Cost Management

  • Set hard limits on context window usage
  • Implement caching for expensive retrievals
  • Monitor per-request costs
  • Optimize summarization frequency