AhmadHassan-BTed/OpenOPC-Shadow-Adapter

openopc-shadow-adapter is a high-concurrency Temporal Bridge for OpenOPC. It allows OpenOPC agentic DAGs to pause non-blockingly when a role requires human sign-off (Carbon) or remote GPU execution (Silicon BYOC), without causing engine timeouts or stalling parallel branches.

1. Non-Blocking Intercept: Intercepts OpenOPC task execution in <50ms, parks the task in an isolated SQLite WAL database, and releases execution threads immediately with AWAITING_HUMAN.
2. Contractor & Silicon Worker Portal: Provides a dedicated, secure React 19 UI and REST API (shadow-serve) for human reviewers and remote workers (shadow-worker).
3. Consolidated Corporate Brain: Automatically packages ancestor deliverables, structured markdown briefs (brief_md), and uploaded file artifacts (CorporateArtifacts) for downstream context inheritance.
4. Canonical State Subordination: Resumes OpenOPC's native store.db state machine (delegation_work_items.phase) instantly when deliverables are submitted.
5. Symbiotic Architecture: Functions as an independent, non-invasive extension that plugs into OpenOPC's external agent registry (ADAPTER_CLASSES["shadow"]) with zero core repository modifications.

Juggling multiple client contracts or simultaneous full-time roles? Turn yourself from an individual contributor into an agency of one. Assign the heavy lifting—writing programs, reviewing complex technical architectures, and completing routine software assignments—to your remote silicon employees. You sit at the top of the hierarchy as the sole human reviewer. Deliver 5x the output to multiple clients simultaneously, approving deliverables asynchronously on your own schedule without burning out.

Lost a developer? Legal reviewer on leave? Analyst at capacity? AI agents perform 90% of preliminary work (research, code generation, test suite execution, drafting). Shadow Adapter routes only the final approval decision to an available human manager.

One operator with the leverage of a 10-person team. Your AI Research Analyst, Dev Team, Marketing Lead, and Legal Counsel operate 24/7. Shadow Adapter queues strategic checkpoints for your review without stalling non-dependent work streams.

flowchart LR
    subgraph Engine ["OpenOPC Agentic DAG Engine"]
        DAG["Multi-Agent DAG Execution\n(Parallel AI Tasks)"]
    end

    subgraph Adapter ["Shadow Mode Plugin"]
        SA["ShadowModeAdapter\n(Non-blocking Intercept < 50ms)"]
    end

    subgraph Store ["Isolated Persistence"]
        DB[("SQLite WAL Store\nshadow_tasks.db")]
    end

    subgraph Portal ["Human Operations"]
        ReactApp["React 19 Human Portal\n(JWT Authenticated)"]
        HumanReviewer["Human Contractor / Reviewer"]
    end

    subgraph ResumeLayer ["DAG Unblock & Resume"]
        OPCStore[("OpenOPC Engine Store\nstore.db (WAL Mode)")]
        UnblockNode(["Downstream DAG Nodes\nResume Automatically"])
    end

    DAG -->|1. Intercept human-backed task| SA
    SA -->|2. Park task record| DB
    SA -->|3. Return AWAITING_HUMAN and release thread| DAG
    DB <-->|4. Query pending queue & Submit deliverable| ReactApp
    HumanReviewer <-->|5. Review brief & attach files| ReactApp
    ReactApp -->|6. Submit deliverable via REST API| SA
    SA -->|7. Write Phase.APPROVED to store| OPCStore
    OPCStore -->|8. Native Phase Hooks Trigger| UnblockNode

1. Task Decomposing & Assignment: When a user launches an OpenOPC session (e.g. opc chat --mode company "Build feature X"), OpenOPC's Manager AI creates work items and assigns them to configured role seats (e.g., senior_developer, legal_counsel).
2. Shadow Intercept (<50ms): Any role assigned preferred_external_agent: shadow is intercepted by ShadowModeAdapter. The adapter parses project goals, compiles a markdown task brief (TaskBriefBuilder), parks a record in shadow_tasks.db, and returns AWAITING_HUMAN to OpenOPC. Execution threads release immediately so parallel DAG tasks continue without timing out.
3. Task Claiming:
   • Human Contractor: Logs into the Contractor Portal at http://localhost:8800, claims the pending task, and opens the interactive TaskWorkspace.
   • Silicon BYOC Worker: A remote GPU node running shadow-worker --role senior_developer polls the API, claims the task, and executes inference on its local model.
4. Deliverable Submission: The worker reviews upstream subagent context, writes solution notes, and attaches deliverable files (up to 5 files / 50MB payload cap). Files are indexed into CorporateArtifacts with SHA-256 integrity hashes.
5. DAG Resumption: OpcResumeRepository updates delegation_work_items.phase in OpenOPC's host store.db. OpenOPC wakes downstream DAG nodes, passing the uploaded artifacts forward.

For complete documentation:

• 📖 Step-by-Step Execution Flow Walkthrough
• 🛠️ Detailed Implementation & Setup Guide
• 📜 Changelog & Compatibility Matrix

openopc-shadow-adapter is built to run as a true symbiont with OpenOPC. You can run the portal server embedded in your main Python process or as a standalone CLI sidecar.

pip install openopc-shadow-adapter

In your main OpenOPC application entry point (e.g., main.py), register the adapter and launch the Human Portal server concurrently in a background thread:

# main.py (Your OpenOPC application entry point)
from opc.layer3_agent.adapters.registry import ADAPTER_CLASSES
from shadow_adapter import ShadowModeAdapter, start_server_in_thread

# 1. Register "shadow" mode into OpenOPC's adapter registry
ADAPTER_CLASSES["shadow"] = ShadowModeAdapter

# 2. Launch Human Web Portal concurrently on port 8800 (single process)
start_server_in_thread(port=8800)

# 3. Launch your OpenOPC DAG pipeline as normal!

In your OpenOPC organization config (.opc/config/company_orgs/company_config.yaml), set preferred_external_agent: shadow for human-backed roles:

# .opc/config/company_orgs/company_config.yaml
roles:
  legal_counsel:
    title: "Human Legal Counsel"
    execution_strategy: external
    preferred_external_agent: shadow  # <-- Intercepted by Shadow Adapter

  senior_architect:
    title: "Human Senior Architect"
    execution_strategy: external
    preferred_external_agent: shadow  # <-- Intercepted by Shadow Adapter

If you prefer running the Web Portal in a separate terminal or Docker container:

shadow-serve --port 8800

• React Human Web Portal: http://localhost:8800
• REST API Base: http://localhost:8800/api/v1

The shadow-worker daemon allows remote PCs, GPU workstations, and dedicated cloud nodes to act as specialized silicon employees. Each remote node runs its assigned role on its own local model or API key without modifying the central OpenOPC engine.

export OLLAMA_HOST="http://localhost:11434"
shadow-worker \
  --server-url "[http://192.168.1.100:8800](http://192.168.1.100:8800)" \
  --username "dev_node_1" \
  --password "secure_pass_1" \
  --role "senior_developer" \
  --provider "ollama" \
  --model "llama3.3:70b"

export LOCAL_ANTHROPIC_KEY="sk-ant-api03-enterprise-key..."
shadow-worker \
  --server-url "[http://192.168.1.100:8800](http://192.168.1.100:8800)" \
  --username "legal_node_2" \
  --password "secure_pass_2" \
  --role "legal_counsel" \
  --provider "anthropic" \
  --model "claude-3-5-sonnet-20241022"

export LOCAL_OPENAI_API_KEY="sk-proj-openai-key..."
shadow-worker \
  --server-url "[http://192.168.1.100:8800](http://192.168.1.100:8800)" \
  --username "qa_node_3" \
  --password "secure_pass_3" \
  --role "qa_tester" \
  --provider "openai" \
  --model "gpt-4o"

You can also embed ShadowWorker into custom Python pipelines on remote nodes:

import asyncio
from shadow_adapter import ShadowWorker

# Custom task handler executing local agent pipeline
async def my_local_agent(task: dict) -> str:
    # Query your local GPU, private database, or custom agent model
    return f"Processed task '{task['title']}' on local node."

worker = ShadowWorker(
    server_url="[http://192.168.1.100:8800](http://192.168.1.100:8800)",
    username="custom_node_01",
    password="password123",
    role="legal_counsel",
    custom_handler=my_local_agent,
)

asyncio.run(worker.run_forever())

A real company doesn't just pass text strings—employees share documents, reports, and data. openopc-shadow-adapter acts as the Central Nervous System for your AI and Human workforce by maintaining a centralized artifact registry.

When a Silicon or Carbon employee finishes a task, their deliverables (PDFs, CSVs, code files) are saved to the centralized CorporateArtifacts registry. This creates an indexed, searchable corporate memory for your entire DAG.

The adapter dynamically parses your OpenOPC company_config.yaml to understand your corporate hierarchy. When a downstream Manager receives a task to "Review the Analyst's work," the adapter automatically packages and injects the Analyst's upstream artifacts directly into the Manager's workspace (via the React Portal or the ShadowWorker API payload).

Employees natively inherit the context of the workers below them. A Human Legal Director reviewing a contract doesn't just get a text summary—they are handed the exact .docx file the remote AI Drafter uploaded 5 minutes prior.

All detailed technical specifications are decoupled from this overview:

• Architecture Specification & Implementation Contracts
• Technical Lifecycle & Sequence Diagram
• State Machine Integration Diagram
• Database Schemas & Tables (shadow_tasks.db)

# Run full anti-fragility & host integration test suite (55 tests)
# Enforces Concurrency, Property-Based Fuzzing, Black Hole Exception Trapping, and OpenOPC Host Mutation Survival
pytest tests/ -v --cov=shadow_adapter --cov-report=term-missing

# Run engine simulator demo
python tests/mock_openopc_engine.py

OpenOPC-Shadow-Adapter | Non-Blocking Human-in-the-Loop Layer for OpenOPC

GitHub Repository | PyPI Package | Issue Tracker | Architecture Spec

Thanks for visiting 🖤 Build for OpenOPC Community