Sprint19 Research & Development
Building reliable AI applications today suffers from scattered prompts, ad-hoc retrieval implementations, and inconsistent agent behaviors. The Context–Memory–Prompt (CMP) Framework introduces a Rails-inspired, generator-driven architecture that treats AI components as version-controlled, first-class citizens. CMP eliminates context drift, enables reproducible AI pipelines, and provides the same architectural discipline to AI development that MVC brought to web applications.
Key Innovation: Generator-driven development that creates domain-specific AI applications with built-in best practices, version control, and drift protection—similar to how Docker standardized deployment or React componentized UI development.
Modern AI development resembles PHP spaghetti code circa 2003. Developers write prompts like this:
You are a helpful assistant. Answer questions about our products.
Here's our product catalog: [massive dump].
Also check these recent support tickets: [another dump].
Format responses in JSON but be conversational...
This approach creates multiple critical failures:
- Context Sprawl: Instructions, knowledge, and templates scattered across codebases
- Reproducibility Crisis: "Conversational blob" prompts return inconsistent results
- Drift Vulnerability: Silent model or corpus changes shift outputs unpredictably
- Audit Impossibility: No verifiable trail of what produced customer-facing responses
- Vendor Lock-in: SDK-specific implementations prevent model provider portability
During the development of this whitepaper, a conversation with an AI assistant began with "expand the thought and challenge ideas" but drifted into sprint planning and technical implementation within 20 minutes. Without explicit context boundaries, even sophisticated AI systems conflate roles—mixing strategic advisor, technical architect, and project manager contexts.
This drift pattern repeats across AI applications: customer service bots that become sales agents, content writers that become editors, research assistants that become decision-makers.
The core insight: Context drift isn't a bug—it's the inevitable result of poor architectural boundaries.
CMP enforces single-responsibility principles across three architectural layers:
| Component | Definition | Examples | Purpose |
|---|---|---|---|
| Context | Declarative instructions, agent roles, tool manifests, safety rules | global.ctx, agent/writer.ctx |
What the system should be |
| Memory | Versioned knowledge stores—vector DBs, episodic logs, external data | memory/rag_store/, episodic.log |
What the system knows |
| Prompt | Pure templates hydrated at runtime with context and memory | prompts/blog_draft.md |
How the system responds |
Just as Model-View-Controller architecture enforced "no HTML in the Model," CMP enforces separation of concerns for AI applications:
Before CMP (Mixed Concerns):
# Prompt contains role, knowledge, and template mixed together
system_prompt = """
You are a customer service agent for TechCorp.
Our return policy is 30 days...
Current inventory: Product A (5 units), Product B (0 units)...
Respond in a helpful, professional tone using JSON format...
"""
After CMP (Separated Concerns):
# contexts/support_agent.ctx
role: "customer_service"
tools: ["inventory_lookup", "return_policy"]
guardrails: ["professional_tone", "json_output"]
# memory/policies/returns.md
Return window: 30 days from purchase date...
# prompts/support_response.md
Based on the customer inquiry: {{ user_query }}
Response: {{ context.respond_professionally }}CMP's killer feature: Domain generators that create complete AI applications with best practices baked in.
# Generate a complete RAG system
ctx generate rag CustomerDocs --db=supabase --embeddings=openai
# Generate an intelligent agent
ctx generate agent SupportBot --tools=web_search,database --memory=episodic
# Generate multi-step workflows
ctx generate workflow ContentPipeline --steps=research,write,reviewEach generator produces:
- Working code that junior developers can understand and modify
- Test suites with drift detection and semantic correctness validation
- Configuration files with sensible defaults and clear customization paths
- Documentation explaining the generated architecture and extension points
/my-ai-app/
├─ contexts/ # System instructions and agent definitions
│ ├─ global.ctx # Shared behaviors and guardrails
│ └─ agents/ # Agent-specific contexts
├─ memory/ # Versioned knowledge stores
│ ├─ schemas/ # Data structure definitions
│ └─ snapshots/ # Point-in-time knowledge captures
├─ prompts/ # Template library
│ ├─ templates/ # Reusable prompt templates
│ └─ fragments/ # Composable prompt components
├─ tools/ # External integrations and functions
├─ workflows/ # Multi-step process definitions
├─ tests/ # Drift detection and correctness tests
├─ environments/ # Dev, staging, prod configurations
├─ .contextrc # Project configuration
├─ context.lock.json # Version locks for reproducible deployments
└─ context-history.log # Audit trail of all context changes
Hybrid Architecture for Maximum Impact:
- Go CLI: Single binary distribution, excellent concurrency for parallel RAG operations
- Python Plugins: Leverage rich AI ecosystem (Transformers, LangChain, MCP SDK)
- Rust Performance Kernels: Optional FFI for embedding operations and vector similarity
Distribution Model:
- Go binary ships with embedded Python environment (like Terraform + providers)
- Plugin ecosystem via pip:
pip install contexto-plugin-pinecone - Docker images for Kubernetes deployment
Lockfile Strategy:
// context.lock.json
{
"contexts": {
"global": "sha256:abc123...",
"agents/support": "sha256:def456..."
},
"memory": {
"customer_docs": "sha256:789ghi...",
"policies": "sha256:jkl012..."
},
"models": {
"primary": "gpt-4o-mini@2024-07-18",
"fallback": "claude-sonnet-4@2024-08-01"
}
}Operational Workflow:
- Author
.ctxfiles and prompt templates → Pull Request - CI runs drift tests, token budgets, semantic correctness checks
- Merge & tag → SHA stamps for all CMP components
- Runtime embeds version SHAs in every LLM call for auditability
- Weekly cron refreshes memory vectors and reruns full test suite
Database-Driven Context Isolation:
CMP_TOKENheader maps requests to user-specific contexts- Each tenant gets isolated SQLite databases for memory stores
- Shared base contexts with user-specific overlays
- Session management prevents context bleeding between users
| Use Case | Traditional Approach | CMP Approach | Potential Impact |
|---|---|---|---|
| Multi-brand Content | Separate codebases per brand | One template repo, brand-specific contexts | Faster campaign iterations |
| Regulated Chatbots | Manual audit trails | Automatic SHA-based provenance | Streamlined compliance workflows |
| RAG Prototyping | Rebuild from scratch | ctx generate rag + data upload |
Rapid MVP development |
| A/B Testing Prompts | Hard-coded variants | Version-controlled prompt branches | Systematic prompt optimization |
The Problem: Building an executive assistant requires RAG (company knowledge), agent capabilities (task execution), memory management (conversation history), and multi-tenant support (different executives).
CMP Solution:
ctx init executive-assistant
ctx generate rag company-knowledge --db=sqlite --embeddings=sentence-transformers
ctx generate agent task-router --tools=calendar,email,slack --memory=episodic
ctx generate workflow meeting-prep --steps=gather-docs,summarize,scheduleResult: Working executive assistant in under 2 hours, complete with:
- Company-specific knowledge base with semantic search
- Task routing based on natural language requests
- Conversation memory that prevents context drift
- Multi-tenant support for different executives
- Built-in testing and drift detection
LangSmith (LangChain): Provides prompt versioning and testing but requires LangChain lock-in. No generator system or architectural opinions.
Weights & Biases (Weave): Excellent for ML experiment tracking, limited AI application structure. No multi-tenancy or deployment patterns.
Humanloop: Prompt management and A/B testing SaaS. Closed ecosystem, no local development story.
Pinecone/Chroma/Weaviate: Vector database solutions without application-level organization or reproducibility.
Custom Solutions: Most teams build one-off prompt management and RAG implementations, reinventing architecture patterns.
CMP's Differentiation:
- Generator ecosystem for rapid scaffolding (others focus on management of existing code)
- Architectural forcing functions that prevent anti-patterns upfront
- Open source with local-first development (vs. SaaS-only tools)
- Multi-tenancy built-in rather than retrofitted
Infrastructure frameworks succeed when they provide:
- Strong opinions (convention over configuration)
- Generator ecosystem (scaffolding productivity)
- Clear separation of concerns (architectural boundaries)
- Vibrant community (shared best practices)
CMP targets these same pillars for AI development. The timing aligns with AI development reaching the complexity threshold where ad-hoc approaches break down—similar to where containerization emerged when deployment complexity became unmanageable.
- Open-source template repository with MIT license
- Go CLI with basic
init,generate,testcommands - Python plugin system for RAG and agent generators
- Reference executive assistant implementation
- Basic CI test kit for similarity-based drift detection
- IDE extensions for VS Code and Cursor
- Community plugin contribution system
- Integration adapters for popular AI frameworks
- Enhanced testing framework
- Comprehensive documentation and tutorials
- Hosted CI service option
- Performance optimizations for large-scale deployments
- Enterprise features: RBAC, audit logging, compliance tools
- Advanced prompt optimization capabilities
- Edge runtime support
Challenge: Vector embeddings aren't like code—they're probabilistic and high-dimensional. Traditional diff tools don't apply.
Current Approach: Content-based hashing with similarity thresholds for cluster comparisons. This remains an active area of research with no perfect solution.
Challenge: Similarity thresholds catch embedding drift but miss semantic correctness issues.
Proposed Solution: Hybrid approach combining statistical similarity measures with business logic tests. Test case generation from knowledge bases is promising but requires domain-specific validation rules.
Challenge: Different models have fundamentally different capabilities and response patterns.
Approach: Standardized context interfaces with provider-specific adapters. Results will vary between providers, but system behavior remains predictable within each choice.
- Core framework: Open source (MIT license) to drive adoption
- Value-added services: Hosted CI, enterprise integrations, professional support
- Community growth: Plugin ecosystem with community contributions
- Monetization: SaaS hosting, enterprise features, consulting services
This follows proven open-core patterns where the community builds on free infrastructure while enterprises pay for operational convenience and advanced features.
Target 1: Platform engineering teams at tech companies building AI features
Target 2: AI consulting agencies building multiple client applications
Target 3: Enterprise development teams with compliance requirements
Channel Strategy:
- Open source adoption → land
- Enterprise features → expand
- Community contributions → network effects
- Development velocity: Measurably faster AI application scaffolding
- Consistency improvement: Reduced variance in AI outputs for identical inputs
- Developer adoption: Community engagement and contribution growth
- Code quality: High utilization rate of generated code without modification
- Migration efficiency: Simplified process for moving existing AI implementations
- Maintenance reduction: Fewer debugging cycles due to improved reproducibility
- Compliance benefits: Streamlined audit trail generation
- Team enablement: Broader team participation in AI development
The Context–Memory–Prompt Framework represents a paradigm shift from ad-hoc AI development to disciplined, reproducible AI engineering. By treating context as code, enforcing architectural boundaries, and providing Rails-level generator productivity, CMP enables teams to build production AI applications with the same confidence and velocity as traditional web applications.
The opportunity is massive: Every company building AI features today is reinventing the same architectural patterns. CMP provides the shared foundation that unlocks the next wave of AI application development.
The timing is right: AI development practices are consolidating around retrieval-augmented generation, multi-agent systems, and prompt engineering best practices. CMP codifies these patterns into reusable generators before the market fragments further.
The execution strategy is proven: Follow the Rails playbook of strong opinions, excellent developer experience, and community-driven growth.
CMP doesn't just solve today's AI development problems—it creates the foundation for tomorrow's AI application ecosystem.
# Install CMP CLI
curl -fsSL https://get.contexto.dev | sh
# Initialize new project
ctx init my-ai-app
cd my-ai-app
# Generate your first RAG system
ctx generate rag knowledge-base --db=sqlite
ctx test
ctx run knowledge-base query "Hello world"# contexts/support_agent.ctx
name: "Customer Support Agent"
version: "1.0.0"
description: "Handles customer inquiries with company knowledge"
role:
persona: "Professional, helpful customer service representative"
capabilities: ["answer_questions", "escalate_issues", "process_returns"]
limitations: ["no_refunds_over_policy", "no_personal_data_sharing"]
tools:
- name: "knowledge_search"
uri: "mcp://search.knowledge_base"
- name: "order_lookup"
uri: "mcp://database.orders"
guardrails:
tone: "professional"
format: "json"
max_tokens: 500
memory:
episodic: true
max_history: 10
privacy: "user_isolated"For more information and to contribute, visit: https://github.com/sprint19/cmp-framework