Interactive Technical Overview
CPUcoin StrataPaper 3.1
Click through the layers of CPUcoin — from access to infrastructure — and drill into the details you need. Now featuring MemFlow CPU session memory, MAITRIX Link cross-platform bridge, and universal IDE integration across 13 development environments.
StrataFlow™ Hybrid Execution
This view shows the directional flow from user interaction and enterprise enablement, through MAITRIX and MemFlow, down into the hybrid decentralized backend. Select any segment to zoom into the detailed technical roles.
User Access Layer
The shared human entry point into MAITRIX. Supports personal, family, and small business use cases through a single language-aware interface.
Who It Serves
- Personal AI
- Family sharing
- SMB workflows
- Enterprise collab
Access
- OAuth
- Apple
Enterprise Enablement
Adds business domain management and governed data connection. Supports Microsoft A/D and Rootz.global attestation.
Control Plane
- Domain management
- Microsoft A/D
- Governed access
Security
- Instant-off security
- Rootz attestation
- Sovereign audit
MemFlow — Shared Agent Memory
MemFlow is the portable shared-memory and prompt-caching layer for coding agents in the CPUcoin ecosystem. It stores validated development knowledge, surfaces canonical code snippets and runbooks on demand, and warns when stored context is stale for the current dependency graph.
Memory Operations
- Store, search & retrieve
- Session checkpoint & resume
- Session compaction
- Pattern promotion
- Import / export / merge
- Legacy RuFlo migration
Storage Backends
- Embedded in-memory (app tier)
- SQLite — local default
- MongoDB — shared teams
- Deterministic across all tiers
- Local-first by default
Retrieval & Routing
- Hybrid exact + semantic recall
- Snippet RAG for code blocks
- Workflow pre-flight routing
- Dependency-linked invalidation
- Prompt cache reuse
MCP Integrations
- Cursor · VS Code · Continue
- Claude Code · Claude Desktop
- OpenAI Codex CLI · Windsurf
- Cline · Sourcegraph Cody
- Any MCP-capable IDE or CLI
Infrastructure Foundation
The foundation of CPUcoin: Google Cloud reach combined with CGN decentralized compute, coordinated via PoPW.
Hybrid Capacity
- Google Cloud reach
- CGN decentralized edge
- $CPU coordination
Efficiency
- PoPW productive work
- Sharing economics
- Edge-first routing
Use the hotspots or toolbar to zoom each layer. Then explore the StrataPaper sections below for deeper detail.
Start Here
StrataFlow Architecture
CPUcoin explained as a hybrid decentralized cloud: access, orchestration, compute, and value rails in one view.
- User + enterprise access surfaces (MAITRIX, OAuth, Google, Apple, Microsoft A/D)
- StrataFlow frame with MemFlow policy and language-aware routing
- Hybrid execution spanning CGN miners, enterprise/on-prem nodes, and cloud elasticity
Click for detail »
StrataFlow™ is the narrative wrapper for the full stack. Demand comes from MAITRIX and Tweekit. Requests hit MemFlow for identity, language routing, and policy. MemFlow chooses placement across managed cloud, enterprise/on‑prem nodes, or CGN miners. Economic flow rides two rails: CashFlow™ (Stripe + Everest Euro) and CryptoFlow™ ($CPU, staking, PoPW rewards).
- Access: OAuth/Google/Apple for users; Microsoft A/D + domain control + sovereign audit paths for enterprise.
- Orchestration: MemFlow CPU provides session memory, prompt caching, and agent lifecycle hooks across 13 IDE/CLI environments on all platforms (macOS, Windows, Linux, ChromeOS, WSL).
- Placement: latency/assurance → cloud or enterprise; elastic capacity → CGN miners; always PoPW-measured.
- Value: credits bridge earn → spend; CPU.c → credits → $CPU → stablecoin via Everest (when re-enabled).
- Mobile: MAITRIX Link bridges mobile app to desktop environments via Firestore-synced real-time session monitoring.
Why Now
Problem Landscape
AI, multimodal, and document workloads are outpacing centralized cloud cost and capacity; idle compute stays underused.
- Rising inference + preprocessing demand from AI-native products
- Centralized cloud is expensive and capacity-bound for sustained volume
- Underused enterprise, edge, and consumer compute lacks coordination
Click for detail »
Platform Direction
CPUcoin Thesis
Hybrid decentralized cloud + compute-sharing economy + application-backed demand.
- CGN as execution fabric, not ideology — hybrid by design
- Compute-sharing economy driven by useful work, not abstract mining
- MAITRIX and Tweekit prove demand; StrataFlow/MemFlow explain the path
Click for detail »
CPUcoin moves from “decentralized compute” to “hybrid decentralized cloud + compute-sharing economy.” CGN is the execution fabric, not the brand. MAITRIX/Tweekit supply demand. CashFlow/CryptoFlow make the economics legible to fiat and crypto entrants.
Gaps called out in the current-state baseline: payout automation still manual; identity hardening and policy enforcement uneven across services; some legacy service dependencies remain. 3.0 thesis explicitly separates current from target.
Layered View
Platform Model
Four layers keep the system legible: demand, orchestration, compute, and economic rails.
- Demand: MAITRIX AI hub, Tweekit transformations, future voice/agentic workloads
- Orchestration: identity, workload APIs, publisher/ingestion logic, MemFlow policy
- Compute: managed cloud + enterprise/on-prem + CGN miners for elastic capacity
- Economics: CashFlow (fiat) and CryptoFlow ($CPU, staking, PoPW) working together
Click for detail »
Demand: MAITRIX chat/agents, Tweekit transformations, future voice/avatars/agentic chains.
Orchestration: identity + workload APIs, ingestion/publisher logic, MemFlow policy/context, routing.
Compute: managed cloud (control/latency), enterprise/on‑prem (data residency), CGN miners (elastic edge).
Economics: CashFlow (Stripe + Everest) for fiat; CryptoFlow ($CPU, staking, PoPW) for crypto-native. Credits sit between rails.
Execution Fabric
Computing Global Network
Live services, real workload paths, and clear gaps to close. Describe CGN in present and target states.
- Today: active services and workload pathways; legacy pieces and fragile dependencies remain
- Placement across managed cloud, enterprise nodes, and CGN miners based on policy
- PoPW aligns rewards to completed productive work, not abstract compute
Click for detail »
Current: Live services, CGN routing paths proven through MAITRIX/Tweekit; identity and payouts still partly manual; some legacy/proprietary dependencies.
Target: Automated miner onboarding + payouts, richer attribution, policy-driven placement, attestation tiers. PoPW keeps rewards tied to completed productive work rather than abstract cycles.
MAITRIX & Tweekit
Demand Surfaces
Application-led demand keeps the economy real: MAITRIX for AI access; Tweekit for document/media transformation; future voice/avatars/agents.
- MAITRIX subscriptions drive sustained AI workload volume
- Tweekit normalizes docs/media before AI or rendering pipelines
- Future surfaces: enterprise workflow automation, avatars, voice, agentic chains
Click for detail »
MAITRIX: Multi-model chat, subscriptions, and workflow usage provide sustained inference demand.
Tweekit MCP: Normalizes documents/media; can run on enterprise miners for data residency; demonstrates earn → CPU.c → credits → spend loop.
Next surfaces: enterprise workflow automation, voice/avatars, agentic chains, multimodal media routes.
Value Rails
CashFlow & CryptoFlow
Dual rails keep access flexible: Stripe + Everest for fiat; $CPU for staking, rewards, and PoPW participation.
- CashFlow: global Stripe rails, Everest for Euro; buy services and credits without crypto friction
- CryptoFlow: $CPU for staking, stake-to-earn, PoPW-aligned rewards, credits purchasable with crypto
- Credits bridge earn → spend across MAITRIX, Tweekit, and future services
Click for detail »
Carries forward: off-chain high-rate ledger with on-chain rollups; rewards per productive request; $CPU as network currency.
New in 3.0: credits purchasable with crypto (not just $CPU); explicit split between CashFlow (Stripe global + Everest Euro) and CryptoFlow ($CPU staking, stake-to-earn, PoPW rewards); earn/spend path CPU.c → credits → $CPU → stable via Everest (when re-enabled).
Tiered Controls
Trust, Security, Correctness
Hybrid trust model: managed + enterprise nodes for sensitive jobs; decentralized tiers with policy and future attestation.
- Data-at-rest/in-transit protections; policy-bound routing for regulated data
- Tiered execution: managed cloud and enterprise/on-prem for higher assurance; miners expand capacity where policy allows
- Planned: stronger attestation, attribution, and automated payouts tied to verified work
Click for detail »
Trust tiers: managed cloud + enterprise/on‑prem for high-assurance data; miners for elastic capacity where policy allows.
Protections: data-at-rest/in-transit controls; policy-bound routing; MCP isolation for enterprise ingest.
Planned: stronger attestation, automated verified-work payouts, richer attribution. Avoids claiming end-to-end trusted execution is solved today.
Execution Steps
Roadmap: Current → Target
Treat the roadmap as transition, not futurism. Harden first, then scale demand and trust.
- Phase 1 (now): harden CGN services, identity, payouts; ship miner + tweekit-mcp hybrid path; formalize CashFlow/CryptoFlow
- Phase 2: mature hybrid routing across cloud/enterprise/miners; MAITRIX-driven growth; automate credit conversions
- Phase 3: expanded AI/voice/agentic workloads; richer attestation and policy enforcement; broader third-party DServices
Click for detail »
Phase 1 (now): harden CGN services, identity, payouts; ship miner + tweekit-mcp hybrid path; formalize CashFlow/CryptoFlow.
Phase 2: mature hybrid routing across cloud/enterprise/miners; MAITRIX-driven demand growth; automate credit conversions.
Phase 3: richer attestation/policy enforcement; expanded AI/voice/agentic workloads; broader third-party DServices.
Why This Wins
Strategic Conclusion
Hybrid beats purity; application-backed demand beats token-first narratives; productive work anchors the economy.
- Underused compute becomes useful when policy, routing, and incentives align
- AI demand makes the model urgent; hybrid placement makes it credible for enterprise
- Success metric: turning productive demand into trusted execution and sustainable value flow
Click for detail »
Success = turning real demand into trusted execution and sustainable value flow. StrataFlow/MemFlow keep the architecture legible; CGN executes; CashFlow/CryptoFlow settle and reward; MAITRIX/Tweekit prove demand. Hybrid beats purity for enterprise adoption.
Deep Dive
MemFlow CPU: Session Memory & Token Savings
MemFlow CPU is the portable shared-memory and prompt-caching engine that powers agent lifecycle management, session persistence, and cross-conversation token savings.
- Agent lifecycle hooks: agent_prepare loads profiles, patterns, cached prompts, and session checkpoints at conversation start
- agent_finalize stores session state, auto-compacts conversation context, and caches prompt/response pairs for future reuse
- Auto-compaction: every finalize now produces checkpoint + compacted state — enabling resume without full context reload
- Estimated 3,600+ tokens saved per session resume; prompt cache hits save entire re-inference cycles
- Rootz provenance: high-confidence patterns auto-anchored via Merkle relay for tamper-proof audit trails
- PEQV Phase 1: post-finalize commitment detection scans agent output for verifiable claims
Click for detail »
The Savings Pipeline: When an agent calls agent_prepare, MemFlow loads profiles (persona blocks), resumes from the latest session checkpoint, retrieves compacted session state, searches for relevant patterns and workflows, and checks the prompt cache. If a cache hit is found, the entire inference can be skipped — saving the full token cost of re-generation.
Automatic Compaction: When agent_finalize is called, MemFlow stores a session checkpoint, auto-compacts the conversation into a dense state object (decisions, active files, blockers, next steps), and caches the prompt/response pair. The compacted state is what agent_prepare resumes from on the next conversation — avoiding the multi-thousand-token cost of replaying full conversation history.
47 MCP Tools: MemFlow exposes a full MCP server with tools for memory CRUD, semantic search, session management, prompt caching, profile management, pattern promotion, provenance verification, mobile integration, and operational metrics. All tools are available to any MCP-compatible agent (Claude Code, Codex CLI, VS Code, Xcode, Android Studio, Visual Studio).
- memory_store / memory_search / memory_retrieve: Core memory operations with embedding-based semantic search
- memory_session_checkpoint / memory_session_resume / memory_session_compact: Session lifecycle management
- memory_agent_prepare / memory_agent_finalize: All-in-one lifecycle hooks that orchestrate the full savings pipeline
- memory_cache_auto_get / memory_cache_auto_store: Automatic prompt-response caching with similarity matching
- memory_pattern_promote: Extract reusable patterns from sessions with auto-Rootz anchoring
- memory_audit / memory_merkle_anchor / memory_merkle_verify: Enterprise provenance and tamper detection
Deep Dive
MAITRIX Link: Cross-Platform Bridge
MAITRIX Link connects the mobile MAITRIX app to desktop development environments via Firestore-synced bridge, enabling remote session monitoring, target switching, and mobile-to-desktop agent communication.
- Persistent Firestore sync: runs unconditionally when configured — no dashboard dependency required
- Real-time active session scanning: discovers all running IDEs and CLI tools every heartbeat cycle
- Cross-platform process detection: macOS, Windows, Linux, ChromeOS (Crostini), and WSL
- WSL cross-boundary scanning: reaches across from WSL to Windows host and vice versa
- Mobile agent communication: read inbox, respond, heartbeat, and push notifications via MCP tools
- Token-based pairing: JSON pairing payload with 3-tier refresh strategy for connection resilience
Click for detail »
Architecture: The MemFlow CPU MCP server starts a background Firestore sync on initialization. This sync runs independently of the MemFlow dashboard — making it fully persistent as long as any MCP-connected agent is active. The sync heartbeats every 30 seconds, scans running processes to discover active targets, refreshes authentication tokens, and reports status to the mobile app.
WSL Support: Windows developers using WSL face a split environment where tools run on both sides. MAITRIX Link detects WSL via /proc/version and automatically reaches across boundaries: from WSL, it calls powershell.exe to discover Windows GUI apps (VS Code, Android Studio); from Windows, it calls wsl ps aux to find CLI tools inside WSL containers.
Connection Resilience: The pairing system uses a 3-tier token refresh strategy. If the Firestore ID token expires, it refreshes from the stored refresh token. If the refresh token is revoked, it falls back to re-authentication. Connection status is shown in the mobile UI with color-coded indicators (green/yellow/red).
Target Switching: From the mobile app's Connect page, users see all active sessions with tool-specific icons and can switch between them. This enables workflows like monitoring a Codex CLI session while reviewing an Xcode build — all from a phone.
Deep Dive
Universal IDE & Agent Integration
MemFlow CPU detects and integrates with 13 development environments across all major platforms — every tool with MCP support gets the full agent lifecycle and token savings pipeline.
- Antigravity IDE, Antigravity Vibe, VibeCraft, MAITRIX Desktop — native built-in MCP
- VS Code and code-server — via MCP extension ecosystem
- Claude Code CLI and Codex CLI — native MCP client support
- Xcode — native since 26.3 via xcrun mcpbridge
- Android Studio — bundled MCP Server plugin since IntelliJ 2025.2
- Visual Studio — GA MCP since Aug 2025 via .mcp.json + GitHub Copilot agents
- Claude Desktop — visibility-only (MCP client, not a coding tool)
- ag-bridge-cpu — local bridge server for custom integrations
Click for detail »
Process Detection: The scanner uses platform-specific process listing to discover running tools. On macOS and Linux, it uses ps aux. On Windows, it uses PowerShell Get-Process with wmic and tasklist fallbacks. Each tool has documented process signatures for every platform — from .app bundles on macOS to .exe processes on Windows to AppImage/deb binaries on Linux.
How MCP Connects:
- Xcode:
xcrun mcpbridge— enable in Settings > Intelligence > "Allow external agents" - Android Studio: Settings > Tools > MCP Server (bundled plugin, enabled by default)
- Visual Studio: Add
.mcp.jsonto project root — GitHub Copilot agents connect automatically - Claude Code:
claude mcp add memflow -- memflow-mcp - Codex:
codex mcp add memflow -- memflow-mcp - VS Code: Install MCP extension (Roo, Continue, or similar) and configure memflow server
ChromeOS / Chromebook: All Linux-compatible tools work inside Crostini containers. GUI apps use the Sommelier Wayland bridge. code-server is the recommended VS Code option on ChromeOS for web-native performance.
Want the PDF too?
We’ll publish a downloadable StrataPaper 3.2 PDF addendum once the interactive version stabilizes. If you need a compliance copy today, request it and we will share the current controlled draft.
Request Early PDF