v2.1.0 GA Multi-Agent Runtime Gateway · 30-Day Free Sandbox · From $390/mo

Unify Heterogeneous Agent Frameworks in 1 Line of SDK,
Control Reasoning Loops & Isolate On-Premise Secrets

Bridge LangChain · CrewAI · AutoGen · Hermes with zero rewrites, and deploy 7 on-premise middleware engines for loop control, BYOS secret isolation, and token reduction.

View Pricing ($390/mo+) Read API Docs
$ pip install cdx-dock
$ docker pull cdxno1/cdx-a2a-sidecar:2.1.0
01 · 1-LINE DROP-IN
Attach as a 1-line Python SDK wrapper or local Docker Sidecar proxy with zero rewrites.
02 · ZERO-KEY SANDBOX
Evaluate all 7 engines in 30-Day Local Sandbox immediately—no API key or credit card required.
03 · AIR-GAP & INSTANT ROLLBACK
100% Offline Air-Gap with zero external calls—set CDX_BYPASS=1 for instant pass-through rollback.
4 Frameworks Zero-Rewrite 1-Line Protocol Bridge LangChain · CrewAI · AutoGen · Hermes
0-Byte Egress Explicit Pinning & Zero False Positives CDXCloak Local BYOS Vault Restoration
Long-Horizon Early CoT Loop Breaker (Internal Benchmark) CDX-CoT-Guard & TokenPack-10K Memory
~0.3–0.5ms In-Memory Schema Routing (Internal Benchmark) ~85–93% Schema · ~40–55% Payload Saved

Why Do Enterprise Multi-Agent Architectures Hit Production Bottlenecks?

When engineering organizations adopt multiple agent frameworks (LangChain, CrewAI, AutoGen, Hermes), incompatible execution interfaces force developers to maintain hundreds of lines of brittle serialization wrappers. Furthermore, deploying frontier reasoning models (GPT-6 Astra, Claude Sonnet 5.5 Thinking, Gemini 4 Carbon, DeepSeek-R1) on multi-step pipelines frequently triggers repetitive <think> loop timeouts and GPU KV-Cache exhaustion, while unmasked PII or financial identifiers block internal security and compliance reviews.

Agent Framework Core Architectural Strength Standalone Production Bottleneck CDX Agent Dock Middleware Resolution
LangChain / LangGraph
.invoke() interface
Enterprise RAG pipelines, enterprise DB retrieval chains, and stateful DAG orchestration Requires custom BaseTool schema rewrites when invoked by external frameworks and accumulates verbose JSON syntax overhead per turn CDXLangChainDock exposes native tools in 1 line and cuts inter-agent payload tokens by ~40–55% via Mode B bijective slimming (Internal Benchmark)
CrewAI
.kickoff() / .run() interface
Role-based multi-agent task delegation and structured departmental workflow automation Verbose upstream agent reports and 30+ MCP tool schemas overflow context windows and cause constraint amnesia past Step 20 CDXCrewAIDock + CDX-TokenPack-10K retains 10,000-token core specs and cuts tool schema tokens by ~85–93% (Internal Benchmark)
AutoGen (AG2)
.generate_reply() interface
Multi-agent GroupChat code synthesis, static verification, and autonomous debugging loops Reasoning LLMs frequently stall in repetitive <think> loops during multi-turn synthesis, spiking latency and GPU/API costs CDXAutoGenDock + CDX-CoT-Guard intercepts repetitive reasoning loops in ~0.1–0.2ms and saves ~40–60% CoT tokens (Internal Benchmark)
Hermes & SKILL.md
Declarative Markdown SOPs
Cloud, Kubernetes, and DevOps Standard Operating Procedures defined via SKILL.md Injecting dozens of SKILL.md manuals on every turn overflows context windows and risks leaking CLI account credentials CDXHermesDock dynamically selects Top-2 skills in ~1.0–1.5ms (~85–95% reduction) and isolates secrets via CDXCloak

4 Base Core Runtime Engines (Base Plan Included) + 3 Per-Project Enterprise Add-ons

Every Monthly Base Plan (Base Plan) includes the 4 core protocol, compression, routing, and sidecar engines out of the box,
while engineering teams selectively enable the 3 enterprise add-on modules based on each project's security and reasoning workload.

PART A · BASE CORE ENGINES 4 Core Runtime Engines Included in Every Base Plan ($0 Extra)
1-Line Protocol Bridge · Mode B Bijective Slimmer · ~0.39ms Schema Router · Polyglot HTTP Proxy
ENGINE 01 · UNIVERSAL PROTOCOL ADAPTER & HERMES DOCK

① Universal Protocol Adapter & CDXHermesDock

  • Bind heterogeneous agents in 1 line without wrapper rewrites via as_crewai_tool, as_langchain_tool, as_autogen_agent, and bridge
  • CDXHermesDock dynamically selects and compresses Top-K SKILL.md SOPs in ~1.2ms, cutting skill context tokens by ~85–95% (Internal Benchmark)
ENGINE 02 · BIJECTIVE SLIMMER & CDX-TAB (v2.1)

② DockSlimmer (Mode A ↔ B & Lossless CDX-Tab Codec)

  • Compacts general JSON payloads via Mode B and automatically applies lossless columnar dictionary encoding (CDXTAB1:) to uniform 4+ row JSON tables for 54.7–66% reduction
  • 4-condition bijective guard safely routes ragged JSON or sentinel collisions to Mode B—guaranteeing 100% lossless roundtrip via to_mode_a() (Included in all tiers)
ENGINE 03 · MULTILINGUAL TOOL ROUTER (v2.1)

③ CDXArbiter (Multilingual Zero-LLM Tool Schema Router)

  • Routes EN, KO, JA, ES, DE, and FR queries to English SaaS API schemas in <1.3ms in host memory with zero translation LLM calls (100% Top-3 EN / 100% KO·JA·ES·DE across 20 SaaS APIs)
  • Supports real-time relational CRUD over Customer-Owned Storage (BYOS SQLite3/JSON) while preserving upstream LLM KV-Cache hit rates (Included in all tiers)
ENGINE 04 · POLYGLOT DOCKER SIDECAR GATEWAY

④ Polyglot Docker Sidecar (cdxno1/cdx-a2a-sidecar:2.1.0)

  • Integrate Node.js, TypeScript, Go, Java Spring Boot, and Rust backends via local HTTP reverse proxy with zero changes to existing OpenAI/vLLM client SDKs
  • Control session-isolated secret masking, Top-K routing, and Mode B slimming via per-request HTTP headers (X-CDX-Slimmer, X-CDX-Top-K, X-CDX-Pins)
PART B · PER-PROJECT ENTERPRISE ADD-ONS 3 Project-Scoped Enterprise Add-on Modules (Individual or All-in-One 3-Module Suite)
Growth+ Plans Include a Primary-Project CDX-Cloak Security Vault Voucher
ENGINE 05 · BYOS SECRET PINNING VAULT

⑤ CDXCloak (On-Premise Secret Pinning Vault)

  • Explicitly target sensitive template variables (pin_secret) so ordinary dates (2026-10-27) and business quantities (150 items) suffer zero regex false positives
  • Restores real names and account numbers from your on-premise BYOS vault (SQLite3/JSON) in ~0.04–0.1ms upon LLM response and emits cryptographic audit hashes
ENGINE 06 · REASONING LOOP BREAKER

⑥ CDX-CoT-Guard (Reasoning Loop Breaker & KV Damper)

  • Detects and truncates repetitive <think> stagnation loops in frontier reasoning models (GPT-6 Astra, Claude Sonnet 5.5 Thinking, Gemini 4 Carbon, DeepSeek-R1), saving ~40–60% CoT tokens (Internal Benchmark)
  • Features adaptive reasoning depth control and suppresses on-premise inference server (vLLM) KV-Cache memory spikes (~75% VRAM saved)
ENGINE 07 · 10K CONTEXT ∥ 2K ENCRYPTED VAULT (v2.1)

⑦ TokenPack-10K ∥ VaultPack-2K (Parallel Memory & Local Encrypted Vault)

  • TokenPack-10K (All Tiers/Add-on): Share 10,000-token 8-language context across 4 frameworks in <1.0ms via a single local folder (pack_dir) with zero Vector DB
  • VaultPack-2K (Sandbox Trial · Built into Growth+): Physically isolated customer-local Zero-Knowledge AES-256-GCM + AAD vault—100% secret retention during context overflow, PCI CVV strip, and 1-Bit RBAC
v2.1.0 NEW · ZERO-KNOWLEDGE LOCAL VAULT CDX-VaultPack-2K (10K ∥ 2K Parallel Encrypted Vault)
30-Day Sandbox Trial · Built into Growth ($1,490)+

Physically isolates daily conversation memory (TokenPack-10K) from a dedicated encrypted vault (VaultPack-2K) for addresses, payment cards, bank accounts, and API keys. Even when daily conversation exceeds the 10,000-token (10K) cap and older chatter is evicted, critical user records are never evicted—and 100% of ciphertext and master keys stay strictly on the customer's local host (0 Bytes sent to Cantor Labs).

100% Secret Survival Isolated 2K vault slots never evict when daily 10K context overflows (10/10 verified)
AES-256-GCM + AAD Guard 0 Bytes plaintext on SQLite disk · cross-slot ciphertext tampering immediately rejected
💳 PCI-DSS CVV/CVC Stripping Transient security codes (CVV/CVC) are stripped immediately and never persisted
🪪 1-Bit RBAC Keycards Cloud LLMs (0x00) always denied · only consented local payment tools (0x04) decrypt
Defense-in-Depth local guardrail · Customers retain sole custody of master keys (KMS) and regulatory compliance View VaultPack-2K Code & RBAC Matrix →

Core Workbench #1: Cross-Framework Protocol Bridge & Live Bijective Compression Lab

Inspect production integration snippets for the 4 Base Core Engines included in every Base Plan (Protocol Bridge, CDXHermesDock, CDXArbiter, and Docker Sidecar), and test Mode A (Standard JSON) ↔ Mode B (Structural Bijective Compression) live below.

BEFORE (Manual Glue Code — 40+ Lines of Custom BaseTool & JSON Boilerplate)
class CustomSQLTool(BaseTool): # Manual schema & serialization wrapper per framework
    name: str = "db_searcher"
    def _run(self, query: str) -> str:
        return json.dumps(my_langchain_sql_agent.invoke({"input": query}))
AFTER (1-Line CDX Agent Dock — Automatic Protocol Bridge + 48% Mode B Slimming)
from cdx_dock import as_crewai_tool
# Convert LangChain agent to CrewAI tool in 1 line with lossless payload compression
sql_tool = as_crewai_tool(my_langchain_sql_agent, name="db_searcher", slimmer=True)
from crewai import Agent
from cdx_dock import as_crewai_tool, as_langchain_tool, as_autogen_agent, bridge, CDXHermesDock

# 1) [Universal Protocol Adapter] Convert LangChain · CrewAI · AutoGen agents in 1 line
sql_tool = as_crewai_tool(my_langchain_sql_agent, name="db_searcher", slimmer=True)
lc_tool  = as_langchain_tool(crew_researcher, name="market_researcher", slimmer=True)
ag_agent = as_autogen_agent(my_langchain_sql_agent, name="autogen_sql_specialist")
pipe_opt = bridge(crew_researcher, my_langchain_sql_agent, slimmer=True)

# 2) [CDXHermesDock] Route & compress Top-2 SKILL.md SOPs in ~1.2ms with secret pinning
hermes_dock = CDXHermesDock(hermes_agent, slimmer=True, cloak=True, route=True, top_k_skills=2)
res = hermes_dock.invoke(
    "Verify K8s rolling update and check settlement account status",
    skills=my_skills_catalog,
    pin_secrets={"VIP_CUSTOMER": customer_name, "SETTLEMENT_ACC": account_num}
)
Simulator #1: DockSlimmer Bidirectional Bijective Compression Workbench Saved: -48%
Input: Upstream Agent Response (Mode A Standard JSON · Editable) 118 Tokens
Output: Downstream Mode B Compressed Payload 61 Tokens

Security & Reasoning Workbench #2: On-Premise BYOS Secret Air-Gap & CoT Loop Control Lab

Explore the SDK implementation and interactive verification sandbox for the 3 project-scoped enterprise add-on modules (CDXCloak local secret pinning, CDX-CoT-Guard reasoning loop breaker, and CDX-TokenPack-10K shared memory vault).

from cdx_dock import CDXCloak

# 1) [On-Premise BYOS Vault] Connect to local SQLite3 (.db) with zero external cloud egress
cloak = CDXCloak(storage_path="./enterprise_vault.db")

# 2) [Explicit Secret Pinning] Pin sensitive template variables in 1 line
#    - Prevents regex false positives on ordinary dates (2026-10-27) and quantities (150 items)
cloak.pin_secret("Alex Carter (CFO)", label="VIP_CUSTOMER")
cloak.pin_secret("ACC-9981-7721-0042", label="SETTLEMENT_ACC")

# 3) [Pre-Egress Pseudonymization & ~0.04ms Local Unmasking upon LLM Response]
masked_prompt, session = cloak.mask_text(
    "As of 2026-10-27, settle 150 items for Alex Carter (CFO) on account ACC-9981-7721-0042."
)
# -> Outbound to LLM: "... [[VAULT_PIN_VIP_CUSTOMER_F07F]] ... ([[VAULT_PIN_SETTLEMENT_ACC_92A1]]) ..."
restored_output = cloak.unmask_text(masked_prompt, session)
Simulator #2: 3 Power Add-ons Live Security, CoT & Memory Sandbox 0-Byte Secret Egress · ~0.04ms Unmask
Input: Raw Prompt & Pinned Variables (VIP_CUSTOMER, SETTLEMENT_ACC) 2 Secrets Pinned
Output: Outbound Masked Payload & Local BYOS Unmask Result 0 False Positives · 100% Restored

6-Stage End-to-End (E2E) Execution Pipeline & Engine Specification Matrix

From the moment an application or orchestrator dispatches an agent request until the response returns from an external commercial LLM (OpenAI, Anthropic) or self-hosted cluster (vLLM, TGI), every stage executes within your on-premise VPC boundary in sub-millisecond latency.

STAGE 01 · PRE-EGRESS SECURITY

Explicit Secret Pinning (CDXCloak)

Replaces pinned names, account numbers, and API secrets with session-salted tokens ([[VAULT_PIN_...]]) isolated in your local SQLite vault.

STAGE 02 · SCHEMA & MEMORY ROUTING

Top-K Schema Selection (CDXArbiter)

Retrieves only the Top-K matching MCP tool schemas, SKILL.md manuals, and TokenPack-10K core specs in ~0.39ms.

STAGE 03 · BIJECTIVE COMPRESSION

Structural Payload Slimming (DockSlimmer)

Compresses verbose JSON responses and structured enterprise templates into Mode B format, cutting syntax overhead by ~40–55%.

STAGE 04 · UPSTREAM INFERENCE

Commercial LLM Gateway / vLLM

Only sanitized and slimmed prompts cross the network boundary, reducing GPU KV-Cache footprint and Time-To-First-Token (TTFT).

STAGE 05 · STREAM LOOP CONTROL

Reasoning Loop Breaker (CDX-CoT-Guard)

Monitors streaming <think> chunk stagnation and repetitive patterns in real time via the CDX Black-Box Core to truncate stagnant loops and inject pivot directives.

STAGE 06 · LOCAL RESTORATION & AUDIT

~0.04ms Local Unmask & Telemetry

Restores masked tokens locally using request-scoped session maps and compiles finance, engineering, and security audit telemetry automatically.

Engine Module Plan Tier Latency (P50 / P99) Token & Memory Optimization Storage & Fail-Safe Protocol
① Universal Adapter & HermesDock Base Plan
(Engine 01)
~0.15ms / ~1.20ms SKILL.md SOP context reduced by ~85–95% In-Memory · 3-stage polymorphic execution fallback chain
② DockSlimmer (Mode A ↔ B) Base Plan
(Engine 02)
~0.18ms / ~0.42ms Inter-agent JSON payload reduced by ~40–55% (48.2% sample) In-Memory · Lossless 1:1 roundtrip to Standard JSON (Mode A)
③ CDXArbiter Tool Router Base Plan
(Engine 03)
~0.39ms / ~0.85ms MCP tool schema injection tokens reduced by ~85–93% Customer-Owned SQLite3 / JSON (BYOS) · Zero-downtime bypass
④ Docker Sidecar Gateway v2.1 Base Plan
(Engine 04)
~0.42ms / ~0.95ms Zero-code proxy for Node.js / Go / Java / Rust Local container volume mount · Built-in /healthz probe
⑤ CDXCloak Security Vault Project Add-on
(Engine 05)
~0.04ms / ~0.12ms 0-Byte secret egress · Zero false positives on ordinary numbers Customer-Owned SQLite3 / JSON · Thread-safe session isolation
⑥ CDX-CoT-Guard Middleware Project Add-on
(Engine 06)
~0.12ms / ~0.30ms <think> tokens reduced by 40–60% · KV-Cache ~75% saved In-Memory Stream Filter · 100% preservation of final output
⑦ CDX-TokenPack-10K Vault Project Add-on
(Engine 07A)
~0.65ms / ~1.40ms Long-horizon history capped at 10,000 tokens (-90%+ saved) Local directory (pack_dir) · Zero external Vector DB dependency
⑦-B CDX-VaultPack-2K (10K ∥ 2K) Sandbox Trial ·
Growth+ Built In
~2–5ms (Local AES-GCM) 100% secret retention under overflow · 0-Byte plaintext egress 100% Customer-Local Zero-Knowledge · AAD Guard · CVV Strip · 1-Bit RBAC
View All 3 Copy-Paste Recipes (API Docs Ch. 11) →

“Drop In 3 Lines to Cut Multi-Subagent & AI Coding Token Burn”

AI coding harnesses (Claude Code, Cursor, Cline, Windsurf) and multi-subagent pipelines (Planner → Coder → Reviewer) burn 10–15x more tokens than standard chat because full MCP tool schemas are re-sent every turn, raw files/logs are copied across subagents (O(N²)), and reasoning models spin inside <think> loops. Eliminate token waste immediately with a 1-line proxy URL or 3-line Python SDK wrapper.

Token Drain Stage (40 MCP + 4 Subagents) Without CDX-Dock (Before) With CDX-Dock (After) Active Engine & Mechanism
1. 40 MCP Tool Schemas Full JSON schemas repeated every turn (~18,000 tok) ~1,400 tok (~88–92% saved) CDXArbiter Top-2 routing (<1ms) + MCPOptimizer $defs pruning
2. Subagent Context Handoff Raw files & logs copied verbatim downstream (~42,000 tok) ~14,500 tok (~45–65% saved) CDXTokenPack10K spec recall + Mode B JSON compaction
3. Runaway <think> Loops Model spins on errors until timeout (~22,000 tok) ~3,900 tok (Early loop cut) CDX-CoT-Guard detects repetitive loops & guides final output
4. .env & API Key Protection Plaintext secrets sent externally on config reads 0 Bytes Egress (Local restore) CDXCloak local vault masking ([[VAULT_PIN_...]]) in 0.04ms
Pattern A · Zero-Code Sidecar Proxy for Cursor · Claude Code · Cline
docker run -d -p 8080:8080 cdxno1/cdx-a2a-sidecar:2.1.0
export OPENAI_BASE_URL="http://localhost:8080/v1"
# → Instant Top-K MCP pruning, JSON slimming & .env secret masking
Pattern B · 3-Line Python SDK Wrapper for Multi-Subagent Pipelines
from cdx_dock import wrap_openai, CDXTokenPack10K
pack = CDXTokenPack10K(pack_dir="./team_shared_pack")
llm  = wrap_openai(OpenAI(), slim_prompts=True)
# → Replace full-history copy-paste with sub-ms pack.recall(top_k=2)
* Architectural workflow simulation for a representative 4-subagent + 40-MCP-tool task; actual production token deltas are recorded per call in your local DockTelemetry ledger.

Monthly Base Plans + Per-Project Add-ons & On-Premise Options

Start with a 30-Day All-Access Sandbox ($0) to verify real-world token reduction and security compliance across all modules.
Standard deployments run on predictable monthly base plans (Base Plan) with selectable project add-ons (Cloak Security · CoT-Guard · TokenPack-10K), while high-volume workloads or self-hosted on-premise environments are supported via Custom / On-Prem plans.

[Open Beta Notice · Online Self-Serve Billing Coming Soon] All 7 engines are immediately available via our 30-Day Free Local Sandbox (pip install cdx-dock, no credit card required). Automated online card checkout is currently being finalized; for early commercial CDX2.* licenses or enterprise invoicing, contact support@cdxengine.com.
OPEN BETA & B2B PoC LIVE Zero-Card 30-Day Free Trial (30-Day Sandbox) & Team PoC Onboarding
• Developers · Startups · Engineering Teams: Evaluate immediately via the Dual Interactive Workbenches and pip install cdx-dock under the 30-Day Sandbox ($0 / 150K monthly steps · All modules ON) with zero registration or credit card required.
• Plan Upgrade & Team Rollout (Starter ~ Custom / On-Prem): After your 30-day evaluation, select a fixed-quota plan on our site or request Net-30 corporate invoicing & tailored on-premise licensing.
30-Sec Quickstart → Request Enterprise PoC
STEP 1 Select Monthly Base Plan (Base Plan — Monthly Step Pool & 4 Base Core Engines Included)
Multi-agent baseline: 1 user query ≈ 8–10 internal agent step calls (~1,000 DAU ≈ 500K monthly steps)
First 30 Days Full-Access Free

30-Day Sandbox

30-day evaluation trial to measure token reduction ratios and security compliance prior to production rollout

$0 / first 30 days (No card required)
  • 150,000 monthly agent step quota included
  • Up to 3 Projects · 5 Dev Sub-keys (cdx_dev)
  • 4 Core Engines (Multilingual Arbiter · CDX-Tab) +Cloak +CoT +10K∥2K VaultPack Trial ON
  • Per-project & per-module local telemetry reports
  • Hard quota cap (Spend Cap = ON) enabled by default
Early Startups · ~1,000 DAU

Starter

Seed to Pre-A AI application teams and departmental workflow automation pipelines

$390 / month (Base Plan)
  • 500,000 monthly shared agent step quota
  • 1 Project included (+$49/extra project)
  • 3 Dev Sub-keys (1,500 daily test calls/seat)
  • 4 Core Engines (Multilingual Arbiter · CDX-Tab · Slimmer · Single 10K) built in
  • Supports Lite Tier project add-on modules
Mid-Market SaaS · ~30,000 DAU

Scale

Series B–C SaaS platforms and enterprise technology divisions operating multiple AI products

$4,900 / month (Base Plan)
  • 15,000,000 monthly shared agent step quota
  • 8 Projects included · 30 Dev Sub-keys
  • Includes Primary-Project Cloak Pro ($490) + VaultPack-2K (10K∥2K)
  • Supports Scale Tier high-volume reasoning & memory add-ons
  • Departmental & per-project token usage chargeback reports
High-Traffic Production · ~120K DAU

Enterprise

High-volume AI platforms and multi-team organizations operating fixed-quota production agent fleets

$14,900 / month (Base Plan)
  • 60,000,000 monthly shared agent step quota
  • 25 Projects included · 100 Dev Sub-keys
  • Includes Cloak Scale ($1,690) + VaultPack-2K & Custom RBAC
  • SIEM JSONL audit logs & private cloud VPC deployment
  • Priority engineering support & production SLA
High Volume · Self-Hosted On-Premise

Custom / On-Prem

Tailored plans for high-volume workloads beyond standard quotas or self-hosted on-premise server environments

Custom / Custom Quote (Volume & On-Prem)
  • Custom step quotas exceeding 60M+ monthly calls
  • Self-Hosted On-Premise & Air-Gapped Network Licensing
  • Optimized for in-house GPU inference servers (vLLM, TGI, etc.)
  • Offline hardware-bound license keys for internal security compliance
  • Dedicated onboarding support & flexible contract terms
STEP 2 Per-Project 3 Enterprise Add-on Modules (Select by Monthly Module Call Quota)
Add just +$60–$70 over any 2 modules to unlock all 3 with the [All-in-One 3-Module Suite]
Project Add-on Module Metered Quota Basis (Monthly Module Calls) Lite Grade
(Starter+)
Pro Grade ⭐
(Growth+)
Scale Grade
(Scale+)
Enterprise Grade
(Enterprise)
CDX-Cloak Security
Explicit secret pinning (pin_secret), on-premise BYOS vault & audit hash
Mask / Unmask calls per month +$149 / mo
300K calls/mo
+$490 / mo
1.5M calls/mo
+$1,690 / mo
8M calls/mo
+$4,900 / mo
35M calls/mo
CDX-CoT-Guard
Reasoning model (GPT-6 Astra · Sonnet 5.5 · Gemini 4 · R1) <think> loop breaker & KV damper
Guarded reasoning steps per month +$249 / mo
150K CoT steps/mo
+$790 / mo
750K CoT steps/mo
+$2,490 / mo
4M CoT steps/mo
+$7,900 / mo
20M CoT steps/mo
CDX-TokenPack & Edge
10K local directory shared memory (8 languages) + sub-millisecond spec recall
Memory recall calls per month +$199 / mo
300K recalls/mo
+$590 / mo
1.5M recalls/mo
+$1,990 / mo
8M recalls/mo
+$5,900 / mo
35M recalls/mo
All-in-One 3-Module Suite
Cloak + CoT-Guard + TokenPack integrated suite (Up to 23% bundle discount)
Add a minor increment over any 2 modules
to enable all 3 engines per project
$597
+$460 / mo
$1,870
+$1,450 / mo
(+$70 over CoT+Pack)
$6,170
+$4,890 / mo
$18,700
+$14,500 / mo
LIVE CONFIGURATOR Interactive Base Plan & Project Add-on Quote Calculator
Hard Quota Cap (Spend Cap = ON) Default: $0.00 unexpected overages & zero-downtime Safe Pass-Through
ESTIMATED MONTHLY SUBSCRIPTION QUOTE
$2,791 / mo ($0 first 30 days)
Included Quota: 3,000,000 monthly steps · ~40–65% measured token reduction (Internal Benchmark)
• Monthly Base Plan (Growth) $1,490
• Additional Project Slots $0 (3 projects included)
• Selected Add-ons +$1,450 (3-Module Suite)
• Included Growth Cloak Lite ($149) voucher credit (upgrade diff billed) -$149

Engineering Architecture & Enterprise Deployment FAQ

Key technical specifications frequently reviewed by AI platform engineers, infrastructure leads, and enterprise security teams
regarding upstream framework upgrades, long-horizon reasoning stability, BYOS data sovereignty, and air-gapped licensing.

Q1. Will upstream updates to LangChain or CrewAI break our existing integration code? ▼

Your integration remains stable across upstream upgrades. CDX Agent Dock does not rely on internal private methods; it binds exclusively to public execution protocols (invoke(), kickoff(), and generate_reply()). Combined with a lightweight Python 3.10+ · numpy>=1.24.0 runtime, Zero Outbound Network Dependencies (100% Offline Air-Gap), and a single-variable bypass flag, it guarantees uninterrupted production continuity.

Q2. How does CDX Agent Dock stabilize long-horizon reasoning models (GPT-6 Astra, Claude Sonnet 5.5 Thinking, Gemini 4 Carbon, DeepSeek-R1)? ▼

It prevents repetitive reasoning loop timeouts and protects GPU KV-Cache memory. In our internal benchmarks, CDX-CoT-Guard intercepts repetitive loops inside <think> streams in ~0.1–0.2ms, reducing reasoning token consumption by ~40–60%, while CDX-TokenPack-10K preserves core architectural constraints across multi-step sessions.

Q3. Are sensitive records or tool catalogs ever transmitted externally or locked into proprietary formats? ▼

Zero bytes leave your infrastructure—all records remain isolated in Customer-Owned Standard Storage (BYOS). Both CDXCloak and CDXArbiter persist exclusively to standard on-premise SQLite3 (.db) or UTF-8 JSON (.json) vaults, and explicit variable pinning eliminates regex false positives on dates or business quantities.

Q4. Can Node.js, Go, or Java backends use all 7 middleware engines without rewriting code? ▼

Yes—deploy the Docker Sidecar container (cdxno1/cdx-a2a-sidecar:2.1.0) as a local HTTP reverse proxy. By pointing your existing OpenAI or vLLM client base URL to the sidecar, you can control Mode B slimming, Top-K routing, and secret pinning per request using standard HTTP headers (X-CDX-Slimmer, X-CDX-Top-K, X-CDX-Pins).

Q5. Is there any risk of unexpected overage billing after the 30-day free sandbox? ▼

Hard quota protection (Spend Cap = ON) is enabled by default, guaranteeing $0.00 unexpected overages. If your monthly step quota or 30-day Sandbox limit is reached, the pipeline never crashes or halts—it automatically transitions into zero-downtime Safe Pass-Through mode, notifies you via runtime logs/headers/console, and prompts you to upgrade your plan to resume token savings and acceleration.

Q6. How do you support internal security reviews (static source code inspection) and fully air-gapped deployments? ▼

We provide Open-Core split packaging and offline hardware-bound licenses (CDX-AG-V1). The outer adapter layer (universal_adapter.py, adapters/*) is shipped as inspectable plain-text Python (.py) so security teams can statically verify zero outbound network imports, while private and air-gapped on-premise servers operate 100% offline.