Context Engineering

Advanced cognitive programs are designed for sophisticated reasoning tasks using a cyclical architecture. The framework consists of three primary layers that interact in a loop:

1. Planning Layer: Initiates the reasoning process by defining steps or strategies.
2. Execution Layer: Carries out the tasks defined by the planning layer.
3. Reflection Layer: Evaluates the outcomes of the execution and provides feedback to the planning layer to refine future actions.

This architecture enables adaptability and nuance through a continuous feedback loop between planning, execution, and reflection.

The chatbot is structured into a layered Context Field Architecture:

• Core Layer: Basic conversation handling
• Protocol Layer: Field operations and resonance
• Memory Layer: Persistent attractor dynamics
• Meta Layer: Self-reflection and improvement
• Integration: Unified field orchestration

The project is a statistical arbitrage analysis system implemented as a Telegram bot for cryptocurrency spread trading. It uses a multi-stage pipeline to identify arbitrage opportunities through market filtering, synthetic spread creation, and rigorous statistical testing (stationarity and cointegration).

Core Components

• Bot Core (test/main.py): Uses aiogram 3.4.1 to handle user interactions and orchestration. Settings are stored in settings/*.json.
• Statistical Analysis Pipeline: Includes StationarityFilter, CointegrationTester, GrangerSettingsManager, and MarketDataFilter.
• Calculation Engines: Includes SpreadCalculator, BinanceLotCalculator, and Correlation utilities.

The Orchestration Capstone is the final module of the Context Engineering course. It focuses on transitioning from individual AI components to unified, coherent intelligent systems. The capstone is structured around three stages of mastery: Systems Architecture Mastery, Integration Virtuosity, and Adaptive Intelligence Design, with a final emphasis on Production Excellence.

The capstone architecture is divided into two primary movements:

• Movement I: Foundation Symphony (Weeks 9-10.1)
• Movement II: Emergence Concerto (Weeks 10.2-10.3)

The 20_templates directory contains reusable, composable components for implementing context engineering. Templates follow a progressive complexity model, moving from simple single-prompt 'atoms' to complex 'neural fields' that include persistence and cognitive tools.

Complexity Model: atoms (single prompt) $\rightarrow$ molecules (few-shot) $\rightarrow$ cells (memory/agents) $\rightarrow$ organs (multi-agents) $\rightarrow$ neural systems (cognitive tools/prompt programs) $\rightarrow$ neural fields (fields + persistence).

The repository tracks its architectural evolution through versioned STRUCTURE documents. Use these to understand the theoretical framework, implementation patterns, and directory organization.

• v1.0 (structure.md): Focuses on a biological metaphor (atoms → molecules → cells → organs).
• v2.0 (STRUCTURE_v2.md): Incorporates neural field theory, protocol shells, and concepts like attractors, resonance, boundaries, and emergence.
• v3.0 (STRUCTURE_v3.md): The current advanced meta-recursive architecture featuring meta-recursive frameworks, interpretability scaffolding, collaborative co-evolution, and cross-modal integration.

Protocol-driven context management uses structured templates to optimize token usage and prevent information truncation in AI models. Instead of unstructured text, context is organized into intentional allocations (e.g., System, History, Current, Field) to ensure critical information is preserved within the token budget.

This approach utilizes three complementary methods:

1. Protocol Shells: Structured templates for organizing context.
2. Pareto-lang: A declarative language for context operations.
3. Fractal.json: Recursive patterns for token management.

The bot uses an 8-stage filtering system to identify high-quality arbitrage spreads:

1. Data Acquisition: Loading and validating exchange data.
2. Market Filters: Checking volume, liquidity, and volatility.
3. Spread Creation: Forming and normalizing spreads using the formula log((A*B)/(C*D)).
4. Asset Correlation: Verifying the relationship between assets.
5. Fast Stationarity: Preliminary filtering for speed.
6. Full Stationarity Tests: ADF, KPSS, Hurst exponent, Ljung-Box, and Granger tests.
7. Cointegration: Engle-Granger and Johansen tests.
8. Result: Outputting only high-quality arbitrage spreads.

The project defines a four-layered approach to robust schema architecture. When designing a data modeling system, you should organize your patterns into these layers:

1. Meta-Schema Layer: Handles schema validation, management, pattern composition/inheritance, and cross-schema relationships.
2. Domain Schema Layer: Focuses on business entity/concept modeling, domain-specific validation, and semantic relationships.
3. Structural Pattern Layer: Provides reusable templates for common data structures, composition/aggregation, and standard validation idioms.
4. Primitive Pattern Layer: Defines the fundamental building blocks like basic data types, core validation patterns, and serialization formats.

Cognitive programs are structured, reusable prompt patterns that use programming concepts (variables, functions, control structures, and composition) to guide LLMs through reasoning processes.

A cognitive program follows this basic structure:

function programName(parameters) {
  // Processing logic
  return promptText;
}