For Developers, Tool Builders & AI Agents
No code required.
No ceiling either.
OverMox is visual-first - build with nodes, never type a line. But under the hood lives a full local REST + WebSocket API, 200+ operations, ready for your AI coding agent to read and drive. The floor is friendly. The roof is gone.
OverMox ships a full local API: 200+ REST operations across three layers - Layer 1 builds node graphs, Layer 2 runs around 150 direct actions across many categories, and Layer 3 streams 18 real-time event types over WebSocket. It binds to http://localhost:5000 on your machine and is self-describing for AI agents.
Tween a live object across your scene with one local call - no graph, no build step. Then catch the tween.completed event the instant it settles.
curl -X POST http://localhost:5000/api/actions/tween/position \
-H "Content-Type: application/json" \
-H "X-API-Key: $OVERMOX_API_KEY" \
-d '{
"object": "Cube",
"position": { "x": 0, "y": 3, "z": 0 },
"time": 1.5,
"ease": "easeOutCubic"
}'Sample values shown; the live wire format follows the AsyncAPI spec. The served AsyncAPI (GET /api/events/types) is the source of truth for exact fields.
The Architecture
Three layers, one API
The honest depth showcase. Everything the Controller does by hand, your code does by request - and a real-time stream tells you the moment it happens.
Graph CRUD REST
Build the visual node graphs programmatically. Create graphs, add nodes, wire ports, set values, sync, run and stop - the same flowchart you would draw by hand, scripted. Everything the Controller does by hand, your code does by request.
Direct Actions REST
Fire around 150 one-shot actions across many categories - no graph required. Spawn, transform, tween, shatter, recolor, route output, send MIDI - call a capability and it happens instantly.
Real-time Events WebSocket / SignalR
18 event types streaming live over ws://localhost:5000/api/events - node and graph lifecycle, port and variable changes, console logs, webhook and streaming callbacks. You can even dispatch L2 actions back over the same socket.
Far beyond the scene
It drives the 3D scene - and a whole lot more of your machine.
Scene & Transform
Spawn, move, rotate, scale, parent, color
Physics & Mesh-Shatter
Rigidbodies, colliders, forces, destruction
Animation & Tweens
Transitions, easing, timed motion
Particles & Audio
VFX and audio-reactive control
Camera
Dolly, orbit, look-at, FOV zoom
Files
Read and write on disk
HTTP & Webhooks
Outbound requests, inbound POST listeners
MIDI
Device input and output
Stream Deck
Hardware button triggers
Streaming Events
Twitch, YouTube, StreamElements, StreamLabs
Child Processes
Launch and track external apps
Output Routing
Spout, NDI, resolution, FPS
Math, Array, Text & Data
Transforms and logic
Agent-Ready
Point your AI coding agent at OverMox
OverMox is self-describing. The served llms.txt is the machine-readable front door: it is the canonical orientation document, and it literally tells agents what to do next - GET /llms.txt to understand the whole surface, then GET /api/toc for the full endpoint catalog. Read to understand. REST and WebSocket to drive.
Hand it to Claude Code, Codex, Cursor, Antigravity, or Windsurf. The OpenAPI doc is MCP-friendly, so your agent can wire OverMox into its toolset and start building scenes, automations, and overlays for you - no glue code, no hard-coded knowledge.
Paste this into your agent to orient it:
# Step 1 - understand the API (the canonical orientation doc)
curl http://localhost:5000/llms.txt
# Step 2 - get the full endpoint catalog
curl http://localhost:5000/api/tocThat is it. From there your agent knows the three layers, the 200+ operations, and every event type - no hand-holding required.
What people build with it
Four ways the API turns OverMox from a scene editor into a programmable surface for your whole setup.
Data-driven overlays
Pull live numbers from any HTTP source and push them straight onto a 3D scene.
Stream automation
Subscribe to Twitch and StreamLabs events, fire scene reactions over the socket in real time, and trigger Stream Deck and MIDI.
Custom tooling
Script your own control panels, dashboards, Stream Deck pages, and MIDI rigs against a stable local REST surface.
Agent-built scenes
Describe what you want in plain language; hand your AI agent the llms.txt and let it drive the whole machine - assemble node graphs, fire one-shot scene and physics actions, and wire up real-time events, end to end.
Start Building
Three doors into the docs
Pick the surface that fits how you build. Every card opens the live documentation.
API Guide
Start here. The full orientation: the three layers, key concepts, a health check, and your first graph step by step.
REST Reference
Every endpoint across L1 and L2, with methods, paths, and request shapes. 200+ operations, browsable, with examples.
L3 Event Stream
The 18 real-time event types and the WebSocket / SignalR hub methods. Subscribe, stream, and send actions back.
FAQ
Developer questions, answered
The honest details on what the API is, where it runs, and how agents drive it.
Is there an API?
Yes - a full one. OverMox ships a developer API with 200+ REST operations across three layers: Graph CRUD, Direct Actions, and real-time WebSocket events, plus 18 event types. It's documented with OpenAPI 3.0.1, AsyncAPI 3.0.0, and a served llms.txt, so it's fully self-describing for both humans and agents.
Does it run locally?
Entirely. The API binds to http://localhost:5000 on your own machine, with the event stream at ws://localhost:5000/api/events. It's off by default, loopback-only, and gated behind an auto-generated access token - discovery endpoints like /api/toc stay open, while anything that touches your scene needs the key. Need another device on your network? Optional LAN mode adds HTTPS, certificate pinning, and an IP allowlist. Nothing leaves your computer, and there's no cloud account to set up.
Can an AI agent control it?
Yes, and it's built for exactly that. The OpenAPI doc tells agents to GET /llms.txt for orientation, then GET /api/toc for the full catalog. The specs are MCP-friendly, so Claude Code, Codex, Cursor, Antigravity, or Windsurf can read the whole surface, understand it, and drive the entire environment over localhost.
Do I still get no-code?
Always. No code required is the promise, and it does not change. The Controller's visual node graphs stay the primary, fully-supported way to build - if you can use a flowchart, you can use OverMox. The API is the ceiling-remover for anyone who wants to script it, automate it, or hand the wheel to an agent. Never a replacement, never a requirement.
What can the API do beyond the 3D scene?
Far more than move cubes. Beyond scene, transform, physics, animation, particles, audio, tweens, mesh-shatter, and camera, its actions reach files, HTTP requests, inbound and outbound webhooks, MIDI device I/O, Stream Deck, live-streaming platform events, child processes, and output routing over Spout and NDI - plus math, array, text, and data transforms.
How do I discover what is available?
The API tells you. GET /llms.txt is the canonical orientation, GET /api/toc lists every endpoint, and GET /api/actions/schema details every Layer 2 action. Runtime discovery endpoints enumerate your live scene objects, Bundled Assets, components, and MIDI devices on demand - no guessing.
How do real-time events work?
Connect to the WebSocket / SignalR hub at ws://localhost:5000/api/events and subscribe to any of the 18 event types - node and graph lifecycle, port and variable changes, console logs, webhook and streaming callbacks. You can also dispatch L2 actions back over the same socket for continuous, low-latency control.
Your agent is ready. Is your scene?
Open the docs, point Claude Code at the llms.txt, and start driving OverMox from code.