UNIVERSAL MCP EXECUTION BRIDGE · AGENT HARNESS FOR CHATGPT WEB

AI Thinks.
Nexus Executes.

Nexus is neither an AI Agent, nor a Planner or Reasoner.
Nexus is the Universal MCP Execution Bridge and local physical Agent Harness purpose-built for ChatGPT Web (chatgpt.com) (with broader WebAI platform support coming in future updates). It bridges the gap between cloud LLM cognition and your physical OS with deterministic local execution.

“Web AI provides intelligence.
Nexus provides the local execution layer.
Give AI a way to act.”
< 8ms
MCP Dispatch Latency
100%
Physical State Verified
0
Cloud Data Egress
WAL
Crash-Resilient Ledger
NEXUS HARNESS · LIVE EXECUTION PIPELINE
ACTIVE
ChatGPT Intent
➔
MCP Bridge
➔
Nexus Harness
➔
Windows Kernel/OS
➔
Evidence Verified
AI INTENT Open Blender and create a sphere
MCP PROTOCOL application.launch ➔ computer.state ➔ mcp.execution
NEXUS RUNNER CONNECTED (PID: 14208 · JobObject: JO_NEXUS_01)
PHYSICAL ACTION launch blender.exe --python-expr 'bpy.ops.mesh.primitive_uv_sphere_add()'
LEDGER STATUS EXECUTING (Step 4/5 · Viewport Introspection)
WORLD STATE HWND 0x00320E4A visible · Mesh('Sphere') detected (vertices: 482)
VERIFICATION PASS · Verification Certified
PRODUCT POSITIONING & ARCHITECTURAL REALITY

Why a Dedicated Local Execution Harness?

Modern Web AI (such as ChatGPT Web) excels at intent understanding and reasoning, yet remains trapped inside browser sandboxes.
Conflating the "Planner" with the "Executor" leads to unverified hallucinations, broken environments, and irreversible state pollution.

WebAI Cognition Layer

ChatGPT Web (More Platforms Coming Soon)
  • ✓ Intent Understanding: Parses ambiguous natural-language goals
  • ✓ High-Level Planning: Decomposes macro goals into logical stages
  • ✓ Reasoning & Logic: Multi-step context synthesis and code generation
  • ✓ Replanning: Dynamically adapts strategy from execution feedback
  • ✓ Skill Selection: Selects appropriate domain tool contracts
MCP BRIDGE

Nexus Execution Harness

Universal MCP Bridge / Native OS Host
  • ✓ MCP Execution: Standard Model Context Protocol bidirectional gateway
  • ✓ Native OS Execution: Win32/WinRT & JobObject hardware-quota sandboxes
  • ✓ Action Ledger: SQLite WAL write-ahead logging & cryptographic receipts
  • ✓ Computer State: HWND window trees, UI Automation & filesystem telemetry
  • ✓ Execution Verification: Ground-truth physical assertions, zero fake completions
CORE PRINCIPLE
“Execution ≠ Success=true. Evidence certifies reality.”
An API returning success=true is not proof—only verifiable physical world-state evidence certifies an action occurred.
Read Deep-Dive Architecture ➔
SYSTEM ARCHITECTURE PREVIEW

3-Tier Decoupled Architecture

Strict three-tier separation decouples cloud AI cognition from your local operating system, eliminating privilege creep and state pollution.

TIER 1 · COGNITION

WebAI Cognitive Intelligence

Deeply integrated with ChatGPT Web (chatgpt.com), with additional WebAI platforms coming soon. Handles intent parsing, multi-step planning, and replanning.

LLM Cognition Zero System Privileges Intent Reasoning
TIER 3 · PHYSICAL

Nexus Local Harness & OS

Runs natively on your machine with Tool Registry, isolated Runner processes, Action Ledger WAL, and OS state introspectors.

Native OS Kernel JobObject Sandboxing WAL Receipts
EXECUTION CAPABILITIES

7 Core Execution Capability Dimensions

Comprehensive physical control over your local environment. Every capability enforces strict JSON Schema validation and verifiable execution receipts.

Computer Control

computer.*

HWND window enumeration, normalized mouse actions, low-level keyboard input, multi-monitor awareness, and physical screen capture.

Win32 HWND Mouse/Keyboard

Filesystem Sandbox

filesystem.*

Canonical realpath anti-jailbreak resolution (fs.realpathSync.native), atomic writes, SHA-256 integrity checks, and directory watching.

Realpath Jail Atomic Write

Runtime & Subprocesses

runtime.*

Windows JobObject hardware sandboxing, hard memory caps, timeout circuit-breakers, bidirectional stdio streaming, and safe env injection.

JobObject OOM Protect

Browser Automation

browser.*

Headless and headed control via Chromium DevTools Protocol (CDP), deep DOM evaluation, network interception, and session persistence.

Chromium CDP DOM Extract

Desktop Application Control

application.*

Drive Blender 3D, Microsoft Office, CAD suites, and any native Win32/WinRT desktop application pipeline programmatically.

Blender 3D WinRT COM

Structured Documents & Reports

document.*

Precision-typeset DOCX official documents, vector PDF rendering, and multi-sheet Excel workbook formula & chart generation.

Native OOXML PDF Rendering

Agent Harness Infrastructure

harness.*

Action Ledger Write-Ahead Logging (WAL), Checkpoint snapshot/restore, Durable Execution state machine, idempotency deduplication, and physical ground-truth auditing.

WAL Ledger Durable State Machine Checkpoint/Restore
EXECUTION RELIABILITY & INTEGRITY

Action Ledger & Crash-Resilient State Machine

Every local invocation records an immutable receipt in SQLite WAL.
Even across sudden OS power loss or process crashes, Nexus recovers deterministically with zero duplicate side effects.

Action Ledger Write-Ahead Log (WAL)

Write-Ahead Logging · Immutable Receipts

Before triggering any physical OS mutation (writing files, spawning processes, dispatching input), Nexus commits a prepared intent entry with an Idempotency Key to its local WAL ledger—and seals it with exit codes, SHA-256 hashes, and HWND handles upon completion.

ACTION #1842 · VERIFIED COMMITTED
TOOL: filesystem.write_file
PATH: C:\Workspace\docs\Architecture_Spec.docx
SHA256: 9b4a1c7e283d5f... (Validated)
EVIDENCE: File exists (size: 48,920B, attr: ARCHIVE)

Durable Execution State Machine

Zero Side-Effects · Crash Recovery

If a child process crashes or the host machine reboots mid-task, the watchdog inspects the WAL ledger. Rather than blindly re-running commands, Nexus introspects physical OS state first (checking disk hashes and active handles) before committing or rolling back safely.

STARTED
➔
EXECUTING
➔
CRASH / INTROSPECT
➔
COMMITTED
ENTERPRISE ECOSYSTEM

Developer Extensibility & Zero-Egress Security

Plug-and-play MCP gateway integration for engineering teams, backed by hardware-enforced local privacy and sandbox isolation.

Zero-Config ChatGPT Web Bridge

ChatGPT Web (chatgpt.com) · More Platforms Soon

No expensive API token bills required. Connects directly to your existing ChatGPT Web session over local loopback HTTP/SSE & Stdio to execute real desktop workflows.

View Configuration & Integration Docs ➔

Open Provider & Runner SDK

Node.js / Rust / Python

Extend BaseProvider and register a JSON Tool Schema to plug proprietary hardware, industrial controllers, or internal software pipelines into the Nexus matrix.

Explore SDK Specs & Plugin Guide ➔

Zero Cloud Egress & Isolation

DPAPI / Canonical Path / JobObject

Every file operation is guarded by canonical path verification and allowlists, child processes are isolated in Windows JobObjects, and secrets are encrypted via DPAPI.

Read Enterprise Security Whitepaper ➔
CURRENT SUPPORT, ROADMAP & QUICK START

Quick Start Guide & Platform Roadmap

Follow the 6 steps below to bridge ChatGPT Web directly to your local machine in minutes.

Current (v1.20.0)
Dedicated integration for ChatGPT Web (chatgpt.com).
Roadmap
Support for additional AI clients and platforms will be rolled out in upcoming releases.
01

Install & launch Nexus

Download the installer for your platform from the Releases page (Windows .exe / .msi, macOS Apple Silicon .dmg, Linux .deb / .AppImage), or build from source:
pnpm install && pnpm run build
Open the app and wait for the status bar to show Engine Connected.
02

Create a Tunnel & API Key on OpenAI Platform (free)

You need one tunnel and one API key (one tunnel ↔ one API key). Both are free to create:
⚠️ Security reminder: Your API key is a secret. Never share it, post it in screenshots, or commit it to a repo. Create a dedicated key just for Nexus rather than reusing one from other projects, so you can revoke it independently at any time.
03

Generate your local MCP token

In Nexus, go to Settings → MCP & Tokens. Under Local API & MCP Access Token:
  • Pick a Token Scope preset (Read-Only, Write-Only, Read & Write, Execute, or Full Control), or tick Read / Write / Execute individually.
  • Click Auto-Generate Token & Save to DPAPI. The token is stored encrypted and can be copied any time with the Copy button.
The local endpoint is shown right below: http://127.0.0.1:18080/mcp.
📝 Platform note: DPAPI is Windows-specific, and the labels above are from the Windows build.
04

Configure the Secure MCP Tunnel

On the same page, click Tunnel Settings (Settings → ChatGPT Connection → Secure MCP Tunnel):
  • Outbound Network: choose Direct, System Proxy (auto-detected), or Custom Proxy, depending on your network.
  • Fill in the Tunnel ID and Runtime API Key from step 2, plus the Local MCP Access Token from step 3.
  • Keep Auto-Reconnect & Health Probe enabled.
  • Click Save & Connect, then Test Readiness. When it shows ChatGPT Ready, the tunnel is up.
05

Create the MCP app on ChatGPT Web

On chatgpt.com, open the Plugins page:
  1. Click the + button at the top right.
  2. In the "New plugin" dialog, click Create MCP app.
  3. Enter a Name (and an optional description / icon).
  4. Under Connection, switch from Server URL to Tunnel, then select your tunnel from Available tunnels.
  5. Set Authentication to No authentication.
  6. Tick I understand and want to continue and click Create.
06

Start working

Open a new chat, enable the Nexus plugin, and ask ChatGPT to read files, edit code, run commands, or manage Git worktrees in your authorized project.

Every side-effecting action appears live in the Action Ledger in the desktop app.
💡 Practical Tips
  • Start with read-only access and safe-only execution, then relax permissions per project as you get comfortable.
  • If something doesn't run, check the Action Ledger. Dangerous commands are blocked by default.
  • Use Test Connection / Reconnect on the MCP & Tokens page if the tunnel drops.
PRODUCTION RELEASE v1.20.0 · MULTI-PLATFORM INSTALLERS

Get the Nexus v1.20.0 Execution Harness

Equip your ChatGPT Web workflow with deterministic local OS execution. Available natively for Windows 10/11, macOS Apple Silicon, and Linux.

Windows 10 / 11 Official Installer (NSIS)
Nexus_1.20.0_x64-setup.exe · 60.1 MB · Includes Full Native Runner
Download for Windows ➔