Enterprise software engineering is undergoing a structural transformation as static Continuous Integration and Continuous Deployment (CI/CD) pipelines evolve into dynamic, self-improving agentic architectures1. Traditional development paradigms rely heavily on manual developer intervention to write scripts, manage environments, parse build logs, and review code1. In contrast, the Memory Context (MCA) framework structures application execution around an isolated, managed-first, and continuous architectural loop capable of handling multi-step, complex engineering tasks1.
To execute complex engineering objectives without degrading performance or introducing security vulnerabilities, the MCA framework divides operations across three distinct functional tiers1. This structural separation is modeled after an apex predator triad: the Cheetah, the Eagle, and the Octopus1. The Cheetah provides deterministic compute execution at ground level1. The Eagle functions as the agentic orchestrator, evaluating architectural decisions, enforcing security boundaries, and managing workspace lifecycles1. The Octopus coordinates a fleet of parallel AI worker agents that process non-blocking background tasks, update long-term memory, and optimize context usage1.
The Cheetah: Deterministic Compute and Green Room Sandbox Isolation
At the foundational layer of the agentic software development lifecycle sits the deterministic compute engine, represented by the Cheetah1. Although artificial intelligence models excel at probabilistic reasoning, tasks such as code compilation, system dependency resolution, network socket allocation, and infrastructure provisioning require deterministic execution1. The Cheetah governs the Local Development and Green Room Testing phase, offering fast, synchronous execution where output variance cannot be tolerated1.
Language Mechanics and Local-First Footprint
The deterministic compute tier utilizes a local-first footprint, organizing automation routines into dedicated script files within the scripts/ directory, managed alongside infrastructure declarations in Terraform and environment configurations in .MCA/1. Language selection within the Cheetah layer depends directly on execution requirements:
Python: Executes quick data transformations, JSON manipulations, log structural parsing, and interface glue routines1.
Rust: Delivers high-speed, memory-safe compiled system binaries required for resource-intensive compilation steps and terminal operations1.
Go: Powers concurrent microservice routines, lightweight command-line interfaces, and networking tools1.
Bash: Operates as the POSIX-compliant glue layer for environment provisioning, shell command execution, and file system manipulation1.
Terraform: Declaratively defines, provisions, and aligns sandboxed compute infrastructure with production configurations1.
The Green Room Sandbox Execution Boundary
Before autonomous edits reach production clusters, the Cheetah executes code within a controlled "Green Room" isolation environment1. Mirroring a theatrical green room where actors rehearse off-stage, this sandbox stage executes deterministic code against isolated mock services to verify system behavior1.
Green Room execution depends on precise environment settings, specifically MCA_RUNTIME_IMAGE (specifying the runtime container image) and MCA_SANDBOX_CALLER_SA (identifying the authorized service account)1. Commands run under headless permissions, preventing unverified host mutations or raw operating system access1. This setup allows local scripts to execute synchronously, ensuring full production parity before updates progress to broader cluster environments1.
The Eagle: Agentic Orchestration and Architectural Governance
Operating above the ground-level compute layer is the Eagle—the central control system of the MCA framework1. The Eagle manages the software development lifecycle by evaluating architectural trade-offs, orchestrating workspace transitions, and enforcing security policies across execution boundaries1.
Architectural Choice: Adaptation versus Harness Modifications
When processing complex software engineering objectives, the Eagle decides whether to extend operational capabilities dynamically or modify core system logic1. This creates two distinct operational paths:
Adapt Without Forking: When a task can be solved using existing agent capabilities, the Eagle injects dynamic Markdown guides stored in .agents/skills/SKILL.md1. These files provide step-by-step guidance and dynamic skills at runtime, allowing the agent to complete tasks without altering framework source code1.
Lifting the Harness: When tasks require structural changes—such as registering new API integrations, modifying baseline prompt constraints, or altering execution logic—the Eagle forks and updates core engine files1. This process centers on modifying horizon/agent.py, which updates the global ROOT_AGENT_INSTRUCTION and registers core execution capabilities across the environment1.
The Strict Callback Order Contract
To prevent unintended system modifications, data leakage, or security policy violations, the Eagle enforces a strict callback order contract1. Every request passes through sequential security guard layers before executing actions in the target workspace1:
Layer A (exfil_guard): Scans outgoing network packets, endpoint calls, and external payload structures to block unauthorized data egress.
Layer C (policies_guard): Checks proposed actions against corporate rules, architectural guidelines, and regulatory constraints.
Layer D (permission_guard): Validates execution rights against configuration files stored in .MCA/permissions.jsonl. The agent is strictly blocked from editing files within the .MCA/ directory, preventing autonomous privilege escalation or security rule tampering.
Dynamic Environment Migration and Container Upgrades
Long-running agentic tasks can accumulate temporary files, orphaned background processes, and stale environment dependencies1. To maintain clean environments, the Eagle uses dedicated lifecycle slash commands1:
/reload: Dynamically reloads dynamic skills and dynamic instructions from .agents/skills/ without resetting current task state1.
/sandbox-upgrade: Triggers workspace migration to a fresh base container1. The Eagle packages the /workspace directory via a GET /files/zip call, provisions a new container using MCA_RUNTIME_IMAGE, and restores workspace files via POST /files/zip1. This purges stale container processes while preserving project files1.
In enterprise deployments, user identities and authorization levels are controlled via MCA_AUTH_MODE=iap, enforcing enterprise authentication through Google Identity-Aware Proxy1.
The Octopus: The Parallel Worker Agent Fleet and Continuous Optimization
The third component of the framework is the Octopus, representing the parallel AI worker agent fleet1. Operating during the Production Maintenance and Continuous Optimization phase, the Octopus uses a multi-tentacled, non-blocking operational model1. Powered by the SiblingAgentPlugin, it launches background tasks using asyncio primitives, running system maintenance alongside real-time user interactions1.
Sibling Agent Architecture and Memory Operations
The Octopus isolates background tasks—such as log parsing, contextual fact extraction, and memory consolidation—from the main interaction thread, preserving real-time response times during active coding sessions. The fleet relies on three specialized sibling forks:
1. The Review Fork ("The Judge")
Following each completed turn, the Review Fork executes asynchronously in the background1. Driven by lightweight models such as gemini-3.6-flash, it parses raw execution logs, terminal outputs, and code diffs1. The Review Fork extracts technical facts, developer preferences, and architectural updates, saving them directly into long-term storage via Vertex AI Memory Bank API calls (add_memory and memories.generate)1.
2. The Flush Fork ("Context Rescuer")
As conversation histories expand, language model context windows fill up, increasing the risk that critical details might be lost during context summarization1. This Long Horizon Summarizer equation constantly tracks token usage against a defined threshold1:
Here, 
represents total token capacity and 
(a 75% utilization limit)1.
When token usage reaches this threshold, the Flush Fork executes before context compression1. It extracts key technical facts, active configurations, and unresolved bugs from the window, writing them to persistent memory before context summarization runs1.
3. The Nightly Dream Pass
System optimization continues during off-peak hours through an automated background maintenance pass1. Triggered by Cloud Scheduler via the /scheduler/dream-review endpoint, the Nightly Dream Pass reviews session logs and memory entries1. It deduplicates redundant records, resolves conflicting entries, and refines the Structured User Profile, ensuring the agent remains performant for subsequent tasks1.
Architectural Synthesis and System Lifecycle Operations
The strength of the MCA framework stems from how its three automation layers operate together1. Rather than functioning in isolation, the Cheetah, Eagle, and Octopus form a continuous, self-improving loop1.
End-to-End Operational Lifecycle
An end-to-end task execution illustrates how data flows across the system's operational layers:
Task Ingestion and Governance Validation: An incoming code modification request enters the framework. The Eagle inspects the prompt, determines whether to dynamically load skills from .agents/skills/SKILL.md or modify core logic in horizon/agent.py, and routes the operation through security guards (exfil_guard
policies_guard permission_guard).Deterministic Sandbox Execution: Once authorized, the Eagle routes tasks to the Cheetah layer. The Cheetah provisions an isolated Green Room sandbox using MCA_RUNTIME_IMAGE and executes automation scripts written in Python, Rust, Go, or Bash alongside Terraform configurations. Commands run under headless permissions, verifying safety before changes are accepted.
Environment Refresh: If task execution leaves behind temporary build artifacts, the Eagle executes /sandbox-upgrade. This archives workspace files via GET /files/zip, provisions a fresh base container, and restores workspace state using POST /files/zip.
Asynchronous Memory Consolidation: After execution, the Octopus launches background tasks via the SiblingAgentPlugin. The Review Fork parses output logs using gemini-3.6-flash and updates the Vertex AI Memory Bank. If context utilization reaches MCA_COMPACTION_WINDOW_FRACTION (0.75), the Flush Fork rescues critical technical state before context compression occurs.
Off-Peak Profile Refinement: During off-peak hours, Cloud Scheduler calls /scheduler/dream-review, running the Dream Pass to deduplicate stored facts and refine the Structured User Profile for subsequent engineering sessions.
Enterprise Governance and Repository Layout
Deploying an Agentic AI Software Development Lifecycle within enterprise environments requires clear repository boundaries, explicit permissions, and defined memory controls1.
Workspace Directory Layout
Enterprise repositories using the MCA framework separate governance settings, dynamic skills, core logic, and execution scripts across dedicated directories1:
.agents/skills/SKILL.md: Stores dynamic Markdown instruction sets for runtime skill expansion without code modification1.
.MCA/permissions.jsonl: Configures Layer D security permissions, specifying file access limits (strictly read-only for agents)1.
.MCA/environment.env: Defines core environment settings, including MCA_RUNTIME_IMAGE, MCA_SANDBOX_CALLER_SA, and MCA_COMPACTION_WINDOW_FRACTION1.
horizon/agent.py: Contains core framework instructions, registering default tools and managing the main ROOT_AGENT_INSTRUCTION loop1.
scripts/: Holds deterministic execution scripts written in Python, Rust, Go, Bash, and Terraform1.
workspace/: Contains user application source code, preserved and re-hydrated during sandbox upgrades1.
Operational Control Standards
To maintain environment stability and prevent configuration drift, implementations should enforce four primary operational controls:
Immutable Governance Directories: The .MCA/ configuration folder must remain strictly read-only to autonomous agents within permission_guard rules1. Preventing models from editing their own access rights eliminates a primary path for autonomous privilege escalation1.
Asynchronous Task Isolation: Memory updates, log analysis, and context compaction must run out-of-band via background plugins like SiblingAgentPlugin1. Decoupling system maintenance from the main thread ensures consistent response times during active user sessions1.
Proactive Memory Compaction: Setting context compaction triggers at conservative usage thresholds (e.g., MCA_COMPACTION_WINDOW_FRACTION=0.75) ensures technical details are preserved in persistent storage before summarization runs1.
Container Lifecycle Management: Development environments should routinely refresh container state using commands like /sandbox-upgrade1. Re-hydrating workspace files into clean base containers purges residual background processes and ensures deterministic build environments1.
Conclusion
The Memory Context Framework highlights a fundamental shift in automated software engineering, moving from manual, reactive operations to an integrated, self-improving development lifecycle1. By combining the deterministic speed of the Cheetah, the strategic orchestration of the Eagle, and the multi-threaded memory management of the Octopus, enterprise environments can safely deploy autonomous AI agents that build, validate, migrate, and optimize software systems at scale1.
