CDX Agent Dock Developer Documentation
Complete API reference for LangChain, CrewAI, and AutoGen cross-framework adapters, slimmer / mcp_proxy / route runtime optimization options,
Customer-Owned Standard Storage (JSON / SQLite3 BYOS) CRUD for explicit entity masking (CDXCloak) & tool routing (CDXArbiterEngine), Docker Sidecar v2.1, and Open-Core Security Architecture.
1. Installation & Quickstart (Python SDK v2.1.0 & Docker Sidecar)
cdx-dock v2.1.0 supports both in-process Python SDK (pip) and language-agnostic reverse-proxy container (Docker Sidecar) deployments.
1.1A Official PyPI Package Installation (Python)
1.1B Official Docker Hub Container Installation (Node.js / Go / Java / K8s)
1.2 System Requirements & Compatibility Matrix
Requires Python 3.10+ · numpy>=1.24.0 or a standard Docker runtime environment. Operates with Zero Outbound Network Dependencies (100% Offline Air-Gap) and zero external database servers.
| Component | Supported Specification | Notes |
|---|---|---|
| Python SDK | Python 3.10+ (numpy>=1.24.0) | Compatible with Linux, macOS, and Windows (Zero Outbound Network Dependencies · 100% Offline Air-Gap) |
| Docker Sidecar | cdxno1/cdx-a2a-sidecar:2.1.0 (linux/amd64, arm64) | OpenAI-compatible HTTP proxy for Node.js, Go, Java, Rust, and K8s |
| Agent Frameworks | LangChain, CrewAI, AutoGen, Hermes Agent | Automatic protocol detection for invoke(), run(), GroupChat, and SKILL.md (agentskills.io) |
| BYOS Storage | .json / .db (.sqlite3) | Customer-owned local volumes & Docker volume mounts (-v /data) |
| Package Architecture | Open-Core (.py + .pyd/.so) | Inspectable open-source adapter layer + pre-compiled native execution core |
1.3 30-Second Quickstart
1.4 License Key (CDX_LICENSE_KEY) Setup & Offline Verification
During the 30-Day Free Sandbox (150,000 monthly steps · All 7 engines unlocked), no license key is required—simply install and run. When a monthly step quota or 30-day Sandbox limit is reached, the SDK and Sidecar never halt customer pipelines; they automatically enter Zero-Downtime Safe Pass-Through Mode and emit a runtime/header/console upgrade notice. Upon subscribing to a paid plan (Starter through Enterprise), configure your cryptographically signed offline Ed25519 key (CDX2.<payload>.<sig>) below (unsigned or tampered keys raise CDXLicenseError / HTTP 401):
2. Cross-Framework Adapter Specifications
Core adapter functions that normalize invocation signatures and input/output contracts across heterogeneous agent frameworks, along with an architectural comparison of agent design paradigms.
2.0 Agent Architecture Comparison: Prompt-Only Agents vs. 4 Enterprise Frameworks
While a Prompt-Only Agent (assigning a system prompt persona) can hold conversations, it cannot query internal databases, execute code, enforce step-by-step workflows, or coordinate multi-agent verification. Enterprise teams rely on specialized Agent Frameworks, and cdx-dock bridges and optimizes all of them in a single line:
| Paradigm / Framework | Core Operating Metaphor | Primary Strength | Standalone Bottleneck | cdx-dock Integration Benefit |
|---|---|---|---|---|
| Prompt-Only Agent (Custom GPTs, etc.) |
Verbal-Only Receptionist System prompt persona without orchestration code |
Built in 1 minute without coding | Cannot execute internal tools or enforce deterministic workflow steps | Seamless upgrade path to enterprise frameworks via unified adapters |
| LangChain / LangGraph | Conveyor-Belt Factory (DAG) Strict step-by-step graph ( Step A → Step B → Conditional Branch) |
Fine-grained control for financial & enterprise backend pipelines | Cumulative JSON state across chain steps inflates token consumption | as_langchain_tool / CDXLangChainDock compresses inter-step payloads by 48.2% |
| CrewAI | Corporate Org-Chart & Role-Play Team Assigns Role, Goal, and Backstory to collaborating specialist agents |
Intuitive task delegation for research, planning, and report generation | Verbose inter-agent handoffs and incompatibility with non-CrewAI tools | as_crewai_tool / CDXCrewAIDock adapts external agents in 1 line with payload slimming |
| Microsoft AutoGen | Multi-Agent Debate Room (GroupChat) Coder, Critic, and Executor converse in a loop until consensus |
High accuracy for code generation, debugging, and complex reasoning | Multi-turn conversation history grows exponentially across turns | as_autogen_agent / CDXAutoGenDock trims per-turn message overhead automatically |
| Nous Hermes Agent (agentskills.io) |
Terminal Operator with Procedural Notebook (SKILL.md)Executes CLI/SSH tasks and records reusable Markdown skills |
Autonomous DevOps operations and reusable procedural skill libraries | Injecting dozens of SKILL.md files overflows context and risks leaking secrets |
CDXHermesDock provides <10ms Top-K skill routing + SKILL.md slimming + secret pinning |
2.1 as_crewai_tool()
Converts a LangChain agent, AutoGen agent, or standard Python callable into a CrewAI-compatible tool object.
| Parameter | Type | Default | Description |
|---|---|---|---|
agent | Any | Required | Source agent instance or callable object to adapt |
name | str | None | CrewAI tool identifier (auto-extracted from metadata if omitted) |
description | str | None | Functional description referenced by the agent during tool selection |
slimmer | bool | False | When True, applies Mode B structural compression (-48.2% payload tokens) |
mcp_proxy | bool | False | When True, optimizes tool schema metadata (-36%) and preserves prompt cache alignment |
route | bool | False | When True, enables <10ms in-memory tool routing (-90% schema context overhead) |
2.2 as_langchain_tool()
Converts a CrewAI or AutoGen agent into a LangChain BaseTool compatible instance.
2.3 as_autogen_agent()
Converts a LangChain or CrewAI agent into an AutoGen ConversableAgent for participation in GroupChat sessions.
2.4 bridge(source, target)
Creates a 1:1 execution pipeline that pipes the output of an upstream agent directly into a downstream agent.
2.5 adapt(agent, to='...')
Unified polymorphic interface that returns the appropriate adapter based on the target framework identifier string.
2.6 CDXHermesDock (Nous Hermes Agent & agentskills.io Adapter)
Dedicated adapter for Nous Research's Hermes Agent and agentskills.io (SKILL.md procedural Markdown files), combining ① lossless SKILL.md Markdown compression, ② <10ms in-memory Top-K skill routing, ③ CDXCloak explicit secret pinning, and ④ 1-line export to CrewAI, LangChain, and AutoGen.
3. Runtime Context Optimization Options
All CDX Agent Dock adapters operate in transparent pass-through mode by default. Enable runtime optimizations selectively via boolean flags.
3.1 slimmer=True — Mode A ↔ Mode B Bijective Codec (48.2% Inter-Agent Payload Compression)
DockSlimmer switches payloads reversibly based on who reads the data (Machine DB/APIs vs. Cloud LLMs). Outbound LLM prompts are compressed into Mode B (-48.2% tokens) by stripping JSON punctuation bloat, while enterprise DB writes and REST API responses reconstruct Mode A (Standard JSON) with 1:1 lossless roundtrip fidelity.
| Dimension | Mode A (Standard JSON — DB & APIs) | Mode B (Structured Compact — Cloud LLMs) |
|---|---|---|
| Syntax Structure | Repeats braces { }, brackets [ ], double quotes " ", and commas , |
Strips punctuation bloat using indentation and colons (:) |
| Token & Latency | 142 Tokens (baseline) | 74 Tokens (-48.2% saved) · P50 ~0.18ms · consistent LLM accuracy (internal benchmark) |
| Primary Role & API | Enterprise DB storage, REST API responses, slimmer.to_mode_a() reconstruction |
Inter-agent LLM messaging across LangChain, CrewAI, AutoGen, and Hermes (slimmer.to_mode_b()) |
3.2 mcp_proxy=True (36% Tool Schema Reduction & Prompt Cache Alignment)
Prunes non-essential JSON Schema metadata fields and normalizes static prefixes to maintain high KV-Cache hit rates across OpenAI, Anthropic, and Google models.
3.3 route=True (<10ms In-Memory Top-K Tool Routing)
Evaluates query intent in local memory in 0.25ms–10ms without external LLM or embedding API calls, selecting only the most relevant tools for the turn.
3.4 Combined Production Configuration
3.5 CDX-CoT-Guard — Reasoning Loop Breaker (<think>) & CDX Proprietary KV-Cache Damper
cot_middleware.py breaks runaway repetition loops inside <think>...</think> reasoning traces of modern CoT models (GPT-6 Astra, Claude Sonnet 5.5 Thinking, Gemini 4 Carbon, DeepSeek-R1, QwQ), saving 40–60%+ of wasted reasoning tokens while providing an adaptive reasoning depth clutch gate and CDX proprietary KV-Cache memory optimization (~75% memory reduction).
| Class / API | Deployment Mode | Core Capability |
|---|---|---|
CDXCoTProxyMiddleware |
API Proxy (OpenAI / vLLM / Ollama) | prepare_request() applies premature </think> exit clutch (depth_control) and CDXCloak pinning · inspect_and_guard_stream() breaks streaming CoT loops early |
CDXCoTMiddleware |
On-Premise Context Manager | with CDXCoTMiddleware(model): performs real-time reasoning stagnation detection, adaptive depth control, and step_kv_cache() CDX proprietary KV-Cache memory optimization |
3.6 CDX-TokenPack-10K — Zero-Vector-DB Local Folder (pack_dir) 8-Language 10,000-Token Shared Memory
token_pack.py synchronizes up to 10,000 tokens of high-density long-term memory across heterogeneous frameworks (CDXLangChainDock, CDXCrewAIDock, CDXAutoGenDock, CDXHermesDock) via a single local SQLite storage file (cdx_token_pack_10k.db) inside a user-specified folder (pack_dir)—requiring zero external Vector DB servers. Routine logs are automatically evicted above 10,000 tokens while critical specs, IDs, and numerical facts are permanently retained, with <1.0ms Top-K recall across 8 global languages (KO·EN·JA·ZH·ES·DE·FR·RU).
3.7 [v2.1.0] CDX-VaultPack-2K (10K ∥ 2K Parallel Encrypted Vault) & CDX-Tab Columnar Compression
CDXDualTokenPack physically isolates daily conversation context (10K ContextPack) from permanent sensitive slots (2K VaultPack) so payment cards, addresses, and API keys are never evicted during long sessions. All ciphertext and master keys stay 100% on the customer's local host (Zero-Knowledge) with AES-256-GCM + AAD tamper detection, PCI-DSS transient CVV/CVC stripping, and 1-Bit RBAC least-privilege decryption. (Unlocked in 30-Day Sandbox Trial and Growth $1,490+ plans; Starter tier falls back gracefully via Safe Pass-Through. Provided as a Defense-in-Depth local guardrail—customers retain sole responsibility for master key management and regulatory compliance.)
In addition, DockSlimmer.to_mode_b() automatically applies lossless columnar dictionary encoding (CDXTAB1:) to uniform tabular JSON arrays (4+ rows), reducing payload size by 54–66% with exact 100% roundtrip restoration via to_mode_a().
4. BYOS Data Governance: Explicit Entity Masking (CDXCloak) & Router CRUD
All entity masking dictionaries and tool catalogs are stored strictly on customer-owned storage (BYOS) using universal Standard UTF-8 JSON and SQLite3 relational tables.
4.1 Explicit Entity Masking (CDXCloak) — Zero Unintended Text Mutation Pinning
Enforces strict_pin_mode=True by default so ordinary dates, quantities, and public identifiers are never misidentified by generic pattern scanners. Masks only explicitly pinned entities and restores them locally upon response completion.
4.1.1 Architectural Principle: Why Explicit Pinning (pin_secret) Works Across All Agent Frameworks with Minimal False Positives (Internal Benchmark)
Traditional pattern or heuristic AI scanners frequently corrupt agent reasoning by over-masking ordinary dates (2026-10-17) and quantities, or under-masking internal codenames (Project Titan). CDXCloak achieves consistent deterministic accuracy (internal benchmark) across LangChain, CrewAI, AutoGen, and Hermes using strict_pin_mode=True and explicit pinning (pin_secret) based on two structural invariants:
| Structural Principle | Technical Mechanism | Developer & Security Advantage |
|---|---|---|
| ① Framework Prompt Template & Variable Binding Law | Every enterprise agent framework constructs prompts via Prompt Templates bound to Python variables (e.g., "Check account {account_num} for customer {customer_name}") rather than hardcoded strings. |
Because developers already hold the exact Python variables fetched from internal DBs/APIs (customer_name, account_num, db_key), they can pin those variables directly in 1 line (cloak.pin_secret("ACCOUNT", account_num)) without pattern guesswork. |
| ② Final Outbound Gateway String Serialization Law | Regardless of whether an agent orchestrates via chains (LangChain), role-play (CrewAI), group debate (AutoGen), or terminal skills (Hermes), every framework serializes the final outbound LLM payload into a plain text string/JSON at the invocation boundary (invoke / run). |
cdx-dock intercepts this final gateway to replace pinned variable values with deterministic tokens (<CDX_PIN_ACCOUNT_1>) before outbound transmission, and immediately restores (unmask_text) the original values in local memory upon receiving the LLM response. |
4.2 In-Memory Tool Router (CDXArbiterEngine) — Standard Catalog CRUD
Stores clean relational metadata (name, description, required_params, tags) on disk with zero proprietary binary blobs, allowing direct management via DBeaver or SQLite CLI.
5. Docker Sidecar v2.1 Polyglot Deployment & API Control
Non-Python backend services (Node.js, Go, Java, Rust, C#, Kubernetes) can invoke all cdx-dock v2.1.0 capabilities via OpenAI-compatible /v1/chat/completions proxy endpoints using cdxno1/cdx-a2a-sidecar:2.1.0.
5.1 3-Way Container Control Interface (Env Vars · HTTP Headers · REST API)
5.2 Production Deployment Manifests (docker-compose.yml & Kubernetes Sidecar Pod)
Copy-paste ready infrastructure manifests for co-locating the CDX Sidecar on localhost:8080 alongside your backend service with zero network hop latency and automated /healthz liveness probes:
6. Enterprise Open-Core Architecture & Security Compliance
To satisfy enterprise security and compliance reviews (static source code inspection) while delivering sub-millisecond execution performance and runtime integrity, cdx-dock v2.1.0 separates the Open Adapter Layer (.py) from the Pre-Compiled Native Core Engine (.pyd / .so).
6.1 Package Layer Specifications
| Architecture Layer | Included Modules | Distribution Format | Security Audit & Operational Benefit |
|---|---|---|---|
| Open Adapter Layer | universal_adapter.py, adapters/*, config.py |
Open-Source Pure Python (.py) |
Full source transparency for integration code touching customer agents; enables static verification of zero external data exfiltration |
| Native Core Engine Layer | slimmer_engine, arbiter_engine, shield_engine, etc. |
Pre-Compiled C-Extensions (.pyd / .so) |
Delivers < 1ms native execution performance and guarantees tamper-resistant runtime integrity |
| On-Premise License Guard | license_guard, fingerprint |
Native Binary & Node Identifier | Supports air-gapped VPC deployments with offline hardware node-bound license verification (cdx_mach_...) |
6.2 Inspecting Package Layers & Node Identifier
7. Live Local Telemetry, Self-Audit Report Builder & 1:1 Raw BYOS Export
Cantor Labs enforces a strict Zero Data Custody policy—zero prompts, token counts, tool schemas, or masking records are ever transmitted externally. Your engineering team can query live local telemetry via dock_telemetry, build factual internal reports without vendor estimates via CDXInternalReportBuilder, and export unmodified raw BYOS records in .json or .csv.
7.1 Live Local Telemetry & Persistent BYOS Ledger API (dock_telemetry)
Whenever adapters (slimmer=True), tool routing (CDXArbiter), reasoning guards (CDX-CoT-Guard), entity vaults (CDXCloak), or memory packs (TokenPack-10K) execute, counters update automatically in local memory. Calling bind_byos_storage() persists counters to your SQLite3 (cdx_telemetry_ledger table) or JSON file across server restarts.
7.2 Self-Audit Report Builder & Custom Template Slot Mapping (CDXInternalReportBuilder)
To avoid any vendor bias or guessed dollar figures ($) in internal reviews, live mode (use_live_telemetry=True, default) populates ONLY actual measured runtime counters and real local AST static import checks of installed open adapters (.py). In addition to the 3 built-in templates (Token Settlement / Runtime Ops / Security Audit), any custom template registered via register_template() automatically binds all live {slot_key} variables.
| Report Scope | Measured Fields (Zero Price Guesswork) | Local Data Source | Auto-Bound Template Slots ({slot_key}) |
|---|---|---|---|
| Header ( org_info) |
Department / Author / Period / Environment / Internal LLM Rate Note | Customer input (org_info={...}) |
{company_name}, {author_name}, {reporting_period}, {deployment_mode}, {customer_llm_contract_note} |
| ① Token Settlement ( cfo_roi_settlement_report) |
Measured calls · Raw vs. slimmed tokens · Signed net delta (+/-) · Per-module savings · Internal cost formula |
summary['total_agent_calls']summary['net_tokens_delta']summary['module_token_savings'] |
{monthly_agent_calls}, {raw_tokens_total}, {slimmed_tokens_total}, {saved_tokens_total}, {stage1_arbiter_saved_tokens}, {stage2_slimmer_saved_tokens}, {stage3_cot_guard_saved_tokens}, {stage4_5_memory_saved_tokens}, {customer_cost_formula} |
| ② Runtime Ops ( cto_agent_runtime_report) |
Measured runs & completion rate (%) · Avg latency (ms) · <think> loops broken · TokenPack recall latency · Fallback count |
summary['completion_rate_pct']summary['average_latency_ms']summary['fallback_calls'] |
{connected_frameworks}, {total_pipeline_runs}, {avg_dock_overhead_ms}, {cot_guard_loops_detected}, {cot_timeouts_prevented}, {cot_wasted_tokens_saved}, {tokenpack_recall_latency}, {fallback_activations} |
| ③ Security Audit ( ciso_security_audit_report) |
BYOS vault path · Outbound bytes (0 Byte) · Pinned categories · Masked/restored counts · Live AST static import scan |
reporter.cloak.vault_db_filesummary['cloak_byos']verify_open_adapter_static_imports() |
{byos_storage_location}, {vendor_data_transmission}, {cloak_pinned_categories}, {total_masked_outbound_calls}, {local_unmask_restorations}, {false_positive_mutations}, {static_code_audit_result} |
7.3 1:1 Raw BYOS Data Export (export_byos_raw_data) & License Quota API
To feed internal BI dashboards or compliance pipelines directly, export_byos_raw_data() extracts unmodified raw records across all four BYOS stores (cdx_explicit_vault, cdx_arbiter_tools, pack_entries, cdx_telemetry_ledger) into .json or .csv. Commercial plan pricing and add-on details are available on the Product Pricing Configurator (dock_en.html#pricing).
8. Production Hybrid Pipeline Recipes
Common architecture patterns for cross-framework multi-agent systems in production.
8.1 LangChain SQL Agent ➔ CrewAI Collaborative Team
8.2 [Python Backend Standard] FastAPI + OpenAI SDK End-to-End Integration (Multi-User Request-Scoped Isolation)
Production web server blueprint demonstrating how concurrent user requests isolate their sensitive entities via request-scoped session maps—Combining CDXCloak (entity masking) + CDXArbiterEngine (Top-K tool routing) + the official openai Python SDK:
8.3 [Node.js / TypeScript Standard] Next.js & Express with Official openai NPM Package
Zero new SDK dependencies required—Simply point baseURL in the official openai NPM package to your local CDX Sidecar (http://localhost:8080/v1) and pass per-request X-CDX-* headers:
8.4 [Java Spring Boot Standard] Enterprise Sidecar Integration via RestClient
Standard integration pattern for Java 17+ / Spring Boot 3.2+ financial and enterprise backends routing LLM traffic through the local CDX Sidecar:
9. Zero-Downtime Resilience & Emergency Bypass
Defensive engineering guarantees ensuring uninterrupted service even during upstream framework breaking changes.
9.1 3-Tier Polymorphic Fallback Chain
If a method signature fails, execution automatically shifts to the next standard interface:
9.2 Single-Variable Emergency Bypass Switch
In the event of an unexpected upstream library incompatibility, bypass all wrapping with a single variable without refactoring application code:
10. Adoption Architecture & Enterprise 2-Week PoC Checklist
Recommended deployment patterns and PoC verification workflows tailored by organization profile—from early-stage startups and mid-market SaaS teams to regulated financial, healthcare, and public-sector organizations and air-gapped on-premise deployments.
10.1 Recommended Docking Architecture Matrix Across 4 Enterprise Personas
| Organization Profile | Recommended Runtime | Core Module Combination | Primary Verification KPIs |
|---|---|---|---|
| 1. Startups & AI Agencies | In-Process Python SDK (pip install cdx-dock) |
as_crewai_tool + DockSlimmer (Mode B) |
1-line cross-framework docking · 40–55% lossless LLM payload savings (internal benchmark) |
| 2. Mid-Market B2B SaaS & Platform Teams | Python SDK or Docker Sidecar v2.1.0 |
CDXArbiter + CDX-CoT-Guard + TokenPack-10K |
85–93% tool schema token savings · runaway reasoning loop protection (internal benchmark) |
| 3. Regulated Industries (Finance, Healthcare & Public Sector) | Private VPC / Air-Gapped Sidecar + SQLite3 BYOS | CDXCloak (strict_pin_mode=True) + Local BYOS Vault |
Zero outbound network imports in open adapters · pinned secrets isolated inside customer VPC |
| 4. On-Premise Air-Gapped & Global OEM Fleets | Offline Hardware Node Lock (MachineFingerprint) + Native Binary |
All 7 modules unlocked + SIEM JSONL cryptographic audit logs | 100% offline license verification · centralized multi-project cost & security governance |
10.2 Frictionless 2-Week Enterprise PoC Checklist (30-Day Sandbox)
11. AI Coding Agents & Multi-Subagent Token Diet Recipes
Practical, copy-pasteable integration patterns for cutting quadratic token burn across AI coding harnesses (Claude Code, Cursor, Cline, Windsurf) and custom multi-subagent pipelines (Planner ➔ Coder ➔ Reviewer)—without rewriting your agent logic.
11.1 Why Multi-Subagent & Coding Workflows Burn 10–15x More Tokens (Before vs After)
The table below illustrates an architectural simulation of a single 4-subagent task equipped with 40 MCP tools before and after attaching cdx-dock v2.1.0. (In production, exact per-call token deltas are recorded transparently in your local DockTelemetry ledger.)
| Token Drain Bottleneck | Without CDX-Dock (Before) | With CDX-Dock (After) | Active Engine & Mechanism |
|---|---|---|---|
| 1. 40 MCP Tool Schemas | Full JSON schemas re-injected on every subagent turn (~18,000 tok) |
~1,400 tok(~88–92% reduction) |
CDXArbiter selects only Top-2 relevant tools in < 1ms + MCPOptimizer prunes nested $defs bloat |
2. Cross-Subagent History Copy (O(N²)) |
Raw files & prior chat logs pasted verbatim into downstream prompts (~42,000 tok) |
~14,500 tok(~45–65% reduction) |
CDXTokenPack10K recalls only Top-2 distilled specs + DockSlimmer Mode B compacts JSON tool outputs |
3. Runaway <think> Loops |
Reasoning model spins on compiler/schema errors until timeout (~22,000 tok) |
~3,900 tok(Early loop termination) |
CDX-CoT-Guard detects repetitive reasoning loops and cleanly closes <think> to emit the final patch |
4. .env & API Key Exposure |
Plaintext credentials sent externally whenever an agent reads config files | 0 Bytes Egress( 0.04ms local restore) |
CDXCloak replaces pinned secrets with [[VAULT_PIN_...]] outbound and unmasks responses locally |
11.2 Pattern A [Zero Code Changes] — Attach Local Sidecar Proxy to Cursor · Claude Code · Cline
Launch Docker Sidecar v2.1.0 on your workstation or team dev gateway and point a single Base URL environment variable to http://localhost:8080/v1. Schema pruning, payload slimming, and local secret masking take effect immediately.
11.3 Pattern B [MCP Schema Diet] — Prune 40+ MCP Tool Schemas by ~90% per Turn
Connecting Git, Postgres, Kubernetes, Jira, and Slack MCP servers simultaneously can burn 15,000+ prompt tokens on every turn before the model writes a single line of code. Combine create_arbiter, MCPOptimizer, and wrap_anthropic to inject only the compact Top-2 tools needed for the current step.
11.4 Pattern C [Subagent Handoff Diet] — Eliminate O(N²) Context Copy-Pasting Across Planner ➔ Coder ➔ Reviewer
Instead of copying tens of thousands of tokens of raw files and logs into every downstream subagent prompt, store distilled engineering specs in a shared local CDXTokenPack10K directory so downstream subagents recall only the exact Top-2 specs in < 1ms.
12. [AI-Ready] Complete Engine, Option & API Master Reference (v2.1.0)
A single-page canonical reference engineered so human developers and AI coding agents (Cursor · Claude Code · Antigravity) can immediately distinguish built-in core engines from tier-gated/optional modules and integrate cdx-dock v2.1.0 into production on the first pass.
12.1 Built-in Core Engines vs. Optional Modules & Tier Entitlement Matrix
| Engine / Public Symbol | Category | Plan Entitlement | Primary Function & Measured Impact |
|---|---|---|---|
as_crewai_tool / as_langchain_tool / as_autogen_agent / bridge / adapt / @dock | Core Engine 01 | All Tiers (Sandbox–Enterprise) | 1-line cross-framework agent binding + CDXHermesDock Top-K SKILL.md routing |
DockSlimmer (to_mode_b / to_mode_a / CDXTAB1:) | Core Engine 02 | All Tiers | Mode B JSON compaction + automatic lossless columnar CDX-Tab (54.7–66% reduction on 4+ row uniform tables, 4-condition safety guard) |
CDXArbiterEngine (Multilingual v2.1) | Core Engine 03 | All Tiers | EN·KO·JA·ES·DE·FR queries → English SaaS APIs in <1.3ms zero-LLM memory routing (BYOS SQLite/JSON CRUD) |
MCPOptimizer · AgentDock · wrap_openai / wrap_anthropic / wrap_gemini | Core / Wrappers | All Tiers | MCP schema pruning, local multi-agent mesh bus, and 1-line official LLM SDK wrappers |
CDXCloak · CDXDockShield | Security Vault (Engine 05) | Sandbox / Add-on / Growth+ Voucher | Explicit secret pinning (pin_secret) & regex masking/unmasking (0-byte external egress) |
CDXCoTMiddleware (CDX-CoT-Guard) | Reasoning Guard (Engine 06) | Sandbox / Add-on | Early termination of repetitive <think> loops & vLLM KV-Cache memory damping |
CDXTokenPack10K (Single 10K) | Shared Memory (Engine 07A) | Sandbox / Starter–Enterprise | Zero-Vector-DB local folder (pack_dir) 10,000-token 8-language shared memory |
CDXVaultPack2K · CDXDualTokenPack (10K ∥ 2K) | Parallel Vault (Engine 07B) | Sandbox Trial · Built into Growth ($1,490)+ (Starter: Safe Pass-Through) | 100% customer-local Zero-Knowledge AES-256-GCM + AAD, PCI CVV strip, and 1-Bit RBAC |
12.2 CDXVaultPack2K Role-Based Vault Access Badges (1-Bit RBAC) & Setup Options
Why is this needed? In a real AI application, external cloud LLMs and internal tools (shipping, billing, payment) run side by side. 1-Bit RBAC acts like role-based keycards so each component can only unlock the exact vault drawer it is authorized for.
Example flow: When a user enters both a home address and credit card in chat → the Cloud LLM (ROLE_CLOUD_PLANNER) sees only masked handles → the Shipping Tool (ROLE_ADDRESS_TOOL) can read only the address (card access is automatically denied) → and the Payment Executor (ROLE_PAYMENT_EXECUTOR) decrypts the card locally for a split second only after explicit user_consent=True.
| RBAC Constant (Bitmask) | Allowed Categories | user_consent=True | Intended Caller |
|---|---|---|---|
ROLE_CLOUD_PLANNER (0x00) | None (Always Denied) | Always Denied | External Cloud LLM Planner (0% raw secret exposure) |
ROLE_ADDRESS_TOOL (0x01) | ADDRESS, PHONE, EMAIL | Optional | Local shipping / notification tool |
ROLE_BILLING_TOOL (0x02) | BANK | Optional | Local refund-account / settlement tool |
ROLE_PAYMENT_EXECUTOR (0x04) | CARD, RRN | Required | Local payment execution tool (ephemeral decrypt on consent) |
ROLE_AUTH_EXECUTOR (0x08) | API_KEY, LICENSE | Required | Local authenticated API execution tool |
Key Constructor Options: CDXVaultPack2K(vault_dir="./vault", master_key=kms_32bytes, strict_tier=True) — inject a 32-byte master_key from AWS KMS / HashiCorp Vault; on Starter tier, calls degrade gracefully via Safe Pass-Through and set vault_tier_upgrade_required=True in the returned metadata.