CGN Technology
The Computing Global Network is a hybrid execution fabric. A single workload API places each job on managed cloud, enterprise on-premise nodes, or CGN miner capacity — chosen per request by policy, latency budget, and data-residency constraints rather than by a fixed tier.
Below: how work is defined and placed, how capacity scales, how it is priced and measured, and what is production today versus what is still being hardened.
DService (Decentralized Service)
A DService is the unit of deployable work: a containerized workload plus the policy that governs where it may run. The policy travels with the request, so the same DService can execute on a managed cloud node for a latency-sensitive call and on miner capacity for a batch job, without the caller changing anything.
Tweekit MCP is the reference implementation: document and media normalization packaged as a DService, running on enterprise nodes when a customer requires data residency and on shared capacity when it does not.
- Declared constraints: latency budget, data-residency class, and minimum assurance tier are attributes of the request, not deployment-time configuration
- Placement decision: the workload API resolves those constraints against currently eligible capacity per request
- Container contract: any OCI-compatible image; no CPUcoin-specific SDK is required to be schedulable
- Accounting: every completed execution is attributed for Proof of Productive Work, which is what rewards settle against
Elastic Capacity
Capacity scales by admitting additional miner and enterprise nodes into the eligible pool for a given workload class, not by provisioning larger instances. Throughput therefore grows with the number of nodes that satisfy a request's policy — which is why the constraint on scale is eligible capacity, not raw node count.
This suits parallel, partitionable work: inference, media and document transformation, rendering, and batch preprocessing. It does not suit tightly-coupled jobs that need low-latency interconnect between nodes — distributed training with high gradient-exchange volume belongs on managed cloud, and the placement policy routes it there.
- Scales well: independent per-request work — inference calls, file conversions, render frames, preprocessing shards
- Stays on managed cloud: interconnect-bound and state-heavy jobs, plus anything with a hard tail-latency ceiling
- Redundancy: no node is individually required for a workload class; the control plane remains a managed dependency
Cost Structure
Miner capacity is priced against hardware that is already deployed and already powered. There is no data-center capex, no reserved-instance commitment, and no idle-fleet carrying cost to amortize into the rate — so the floor is set by the marginal cost of running an existing machine rather than by the cost of building capacity.
The trade is explicit: shared capacity is cheaper per unit of work and carries a wider latency distribution than a dedicated cloud instance. Because placement is per-request, a workload can take the lower rate where variance is acceptable and the managed tier where it is not, rather than committing the whole application to one cost profile.
- Billing unit: completed productive work, attributed per execution — not allocated node-hours
- Two payment rails: CashFlow™ (Stripe, and Everest for Euro) and CryptoFlow™ ($CPU), with credits bridging both
- Supplier side: node operators earn against verified completed work rather than uptime or claimed capacity
Latency & Placement
Each request carries a latency budget. The workload API filters the eligible node pool to candidates that can meet it, then places the job — so proximity is one input to that decision alongside current load, measured completion history, and the request's assurance tier.
Where the budget cannot be met by shared capacity, the request lands on managed cloud or a designated enterprise node instead of degrading. The honest framing: edge placement reduces round-trip distance for work that is genuinely local to its data, and CGN's advantage is breadth of placement options per request rather than a uniformly faster network.
- Placement inputs: latency budget, residency class, assurance tier, current load, historical completion record
- Fallback is explicit: unmet budgets escalate tier rather than silently accepting a slower node
Proof of Productive Work
PoPW is the accounting rule that separates this from conventional mining: rewards settle against completed useful workloads — an inference served, a document converted, a frame rendered — not against cycles burned or hashes attempted. A node that consumes power without completing requested work earns nothing.
That makes the energy argument structural rather than aspirational. Work runs on hardware already deployed and already drawing power, and the incentive only pays out when that hardware produces a result someone requested.
- Rewarded: completed, attributed workloads traceable to a paying request
- Not rewarded: idle uptime, claimed capacity, or speculative computation
- Being hardened: automated payout and stronger execution attestation — see current state below
Feedback-Driven Node Selection
Placement improves from outcomes. Each completed execution records which node ran which workload class, whether it met its latency budget, and whether it completed successfully. Those records weight future eligibility, so nodes with a strong record for a given class — media transformation versus inference, for example — are preferred for that class.
This is scoring over observed completion history, not a predictive model making claims it cannot support. Stated plainly because the distinction matters to anyone evaluating the platform seriously.
Production Today vs. In Progress
A hybrid compute network is only credible if it is specific about what is load-bearing now. This is the current split.
Running in production
- CGN services and workload routing, exercised by live MAITRIX and Tweekit traffic
- Placement across managed cloud, enterprise nodes, and miner capacity
- MemFlow CPU session memory and prompt caching across 13 IDE and CLI environments
- Dual payment rails — CashFlow™ and CryptoFlow™ — with credits bridging them
Being hardened
- Miner onboarding and payout automation — parts of the payout path are still operator-run
- Execution attestation: policy-bound routing is enforced today; cryptographic proof of what a remote node executed is not yet end-to-end
- Uniform identity and policy enforcement across all services
- Retirement of remaining legacy service dependencies
StrataFlow™ Architecture
Four layers, from access surface to physical capacity. Select any layer to see what it actually does, what it depends on, and where it hands off.
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
Where demand enters the platform. MAITRIX is the AI access surface — multi-model chat, agents, and workflow usage — and every request that arrives here becomes a placed workload downstream. Language routing is resolved at this layer so the request carries its locale and model preference into orchestration rather than being re-derived later.
Workloads Originated
- Multi-model chat and agent runs
- Document and media transformation via Tweekit
- Workflow automation chains
- Subscription usage — the sustained demand base
Identity In
- OAuth 2.0 / OIDC for consumer sign-in
- Google and Apple as federated providers
- Session established once, carried into orchestration
- Entitlement resolved before placement, not after
Hands Off To
- MemFlow — for context, policy, and routing
- Request arrives with locale, entitlement, and latency class attached
Enterprise Enablement
What an organization needs before it will route real work through a hybrid network: control over which identities may spend, which data may leave the premises, and an audit record of both. This layer binds a customer's existing directory to placement policy, so residency and assurance constraints are enforced by the platform rather than trusted to the caller.
Directory & Control
- Microsoft Active Directory / Entra ID federation
- Domain-verified tenant boundaries
- Group-derived entitlement and spend limits
- Immediate revocation — access ends with the directory record
Data Governance
- Residency class declared per workload
- On-premise nodes for data that cannot leave
- MCP isolation for enterprise ingestion
- Policy engine decides allow / deny / requires-approval
Audit
- Per-execution record: who requested, where it ran, what tier
- Rootz-anchored provenance for tamper-evident history
- Exportable for internal and external review
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
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
Three kinds of capacity behind one workload API. The layer's job is to make them interchangeable where policy allows and strictly separated where it does not — a request never lands on a tier that fails its residency or assurance constraint, and the caller does not choose the tier by hand.
Managed Cloud
- Predictable latency and tail behaviour
- Interconnect-bound and state-heavy jobs
- Control-plane services
- The escalation target when a budget cannot be met elsewhere
Enterprise / On-Premise
- Data that cannot leave a jurisdiction or building
- Customer-operated nodes inside their own perimeter
- Higher assurance tier for regulated workloads
- Tweekit MCP runs here for residency-bound conversion
CGN Miner Capacity
- Elastic capacity from already-deployed hardware
- Partitionable per-request work — inference, conversion, rendering
- Admitted per workload class, by measured completion record
- Paid on Proof of Productive Work, settled in $CPU