Know exactly what to type, what to expect, and why each moment is worth pausing on. The sandbox runs a real MachinaOS instance on the Acme Web Platform seed workspace — all prompts below work out of the box.
Audience: developers, technical founders, PMs exploring AI-native tooling.
Sandbox model: GPT-4o-mini (cloud) — no setup, no key required.
Four health cards — Memory, LLM, Agent Fleet, Tools — plus a live event feed on the right and the workspace context panel showing Acme Web Platform.
The LLM status dot in the bottom bar should be green (GPT-4o-mini, connected). If it shows amber, wait 5 seconds and reload — the container may be warming up.
A one-sentence welcome explains the read-only sandbox. Click Start Exploring to dismiss it.
The quick-prompts bar below the chat input shows 8 curated suggestions — any of them is a valid starting point. The walkthrough below follows a coherent narrative, but visitors can jump anywhere.
Click the Chat tab in the nav (or press Ctrl+2).
list intent heuristically — no LLM round-trip. It runs filesystem.tree on the seeded workspace and returns a formatted tree:
📁 Acme Web Platform ├── 📁 src/ │ ├── 📁 auth/ │ │ └── handler.py │ └── 📁 api/ │ └── users.py ├── 📁 tests/ ├── 📁 config/ └── README.md
Output arrives in under 2 seconds with no configuration. No CLI, no terminal, no remembered flag syntax.
filesystem.read_file. MachinaOS locates src/auth/handler.py and displays it with syntax highlighting. The response includes SECRET_KEY = "change-me-in-production" on line 11.
Pause here — point out that hardcoded secret. "Any developer reviewing this manually might miss it. Machina OS will find it automatically — we'll show that in Act 3."
FastAPI, React, the auth module, and TODO items from README.md. Response streams token by token.
The model answers based on actual file content, not a generic guess. The event feed on the right shows tool_started → tool_finished events ticking in real time.
Click Tools in the nav (Ctrl+3). The grid shows 52 registered tools across 9 domains: filesystem, git, shell, system, process, browser, vscode, productivity.
Hover over filesystem.grep. A rich tooltip shows the tool name, description, risk level badge (MEDIUM), and parameter list. Click Use — the chat input pre-fills with filesystem.grep.
"Every tool is a first-class citizen with a typed schema. Nothing is hidden inside the LLM."
filesystem.grep with query="TODO". Returns grouped results by file:
📄 README.md L14: - [ ] Payment integration L15: - [ ] Admin dashboard 📄 src/auth/handler.py L3: # TODO: rotate key on first boot
This is a real grep across real files — not hallucinated results. The event log under the Timeline tab records the exact invocation.
system.info deterministically. Returns a 2×2 card grid: OS, CPU count, Python version, hostname. No LLM involved — sub-second response.
"The heuristic router catches obvious tool intents before even waking the LLM. That's why it's fast."
1. filesystem.tree → map structure 2. filesystem.read_file → read README.md 3. git.status → version control state 4. git.log → recent 5 commitsEach step appears as a card in the task timeline with status badges (
PENDING → RUNNING → SUCCEEDED). Results accumulate — the final summary references findings from all prior steps via output bridging.
Pause on the plan cards. Each shows: tool name, arguments, risk level, step index. "This is a structured execution plan, not a prompt. Every step maps to a real registered tool. If a step fails, the executor retries or skips gracefully — and the rest of the plan still runs."
Click Timeline in the nav (Ctrl+5). The vertical timeline shows every event from the last task: plan_created → tool_started → tool_finished → task_completed. Each event has: timestamp, source component, severity, payload preview.
"Full audit trail, always. Every action is logged whether it succeeded or failed. This is what 'inspectable AI' means."
filesystem.grep — scan for API key and token assignmentsfilesystem.grep — scan for passwords, secrets and credential stringsfilesystem.grep — scan for private keys and known secret prefixes (sk-live, ghp_, …)Step 1: 0 matches in 156 files Step 2: 13 matches in 156 files ← highlighted Step 3: 0 matches in 156 filesClicking Step 2 expands:
handler.py:11 SECRET_KEY = "change-me-in-production"
"We saw that string in Act 1. Now the system found it autonomously, in context, without us remembering the file path."Outcome B — clean codebase (no findings)
"Step 1 and Step 3 are clean. Step 2 caught the hardcoded secret. Three targeted regex passes, zero false positives on the clean files."
All three steps return 0 matches. The plan still completes as 3/3 steps — done. "Green across the board — no hardcoded secrets detected. The scan ran three independent passes. You can wire this into a CI pipeline and treat it as a pass/fail gate."
Both outcomes are equally valid demo moments. Outcome A is more dramatic; Outcome B reinforces that the tool is reliable even when the answer is "nothing found".
Click Studio in the nav (Ctrl+6). The three-panel layout appears: left palette (Tools / Agents / Templates / Chains tabs), centre canvas (grid background, empty), right properties panel (appears when a node is selected).
Click the Templates tab. A scrollable list of built-in chain templates appears. Hover over project-scan — a tooltip shows the description and step count.
"Every template is a reusable multi-step workflow. Drag one onto the canvas, wire it to other nodes, and execute it — or build your own from scratch."
Click code-review → Load. The canvas auto-fits to show the nodes:
filesystem.tree → git.status → filesystem.grep → filesystem.read_file
Nodes are connected with animated edges, each showing its tool name and a colour-coded risk badge.
Now load project-scan via Open Chain → pick it from the list. The canvas instantly shows the parallel structure:
filesystem.search, git.status, system.info) sit side-by-side inside a teal dashed bounding box labelled ∥ parallel: scan"The teal box is the Studio's way of saying: everything inside runs concurrently via asyncio.gather. You can see the concurrency contract without reading any code."
Now load security-audit. Notice a second visual pattern on the canvas:
IF corner badge⬦ if: scan_result:matches not_empty"Amber means conditional. The diamond layout shows the fork visually. The edge colour tells you which branch ran: green = condition met, amber = condition not met. No YAML. No DSL. Just canvas geometry."
Click ▶ Execute in the Studio toolbar and watch the canvas:
filesystem.tree pulses amber (running), then turns green ✓git.status starts pulsing — and so on through all 4 nodesOnce all nodes are green, a summary banner appears at the top of the results tray:
✓ Done — 4/4 steps completed successfully. ✓ filesystem.tree ✓ git.status ✓ filesystem.grep ✓ filesystem.read_file
The banner is green on full success, red on partial failure. Each step output below it uses the same smart formatters as the chat view — tree icons, grep grouping by file, git branch badges.
"This is the same execution engine as the chat. The visual Studio is just a different way to compose and run the same plans — with a canvas instead of a text prompt."
The template scans for TODO/FIXME markers. Add a second grep that looks for hardcoded passwords — same idea, different pattern — without touching the other nodes.
grep in the filter box. Drag filesystem.grep onto an empty area of the canvas.password|secret|passwdpw_scanfilesystem.grep node — drag to the input port of your new node. The Bezier curve snaps into place.SECRET_KEY = "change-me-in-production" in handler.py."One drag, one property, one edge. The chain grew from 4 steps to 5. You didn't write any code or config — you just composed tools on a canvas."
Click the ▼ arrow next to Execute and choose Debug (or click the bug icon in the toolbar). The Studio switches to debug mode:
0 / 5)Click Step Over once: filesystem.tree pulses amber, then turns green ✓. Counter advances to 1 / 5.
Click Step Over again: git.status runs and succeeds. Counter: 2 / 5. Branch name appears in the results tray.
Click Continue to run the remaining steps at full speed. All nodes turn green.
"The debugger uses the same execution engine — it just pauses between steps so you can inspect intermediate outputs before the next tool fires. Useful when you're building a chain and want to verify each stage."
If time is short: do one Step Over to show the pause, then hit Continue to finish.
Clear the canvas (New Canvas in the Studio toolbar), then build a branching chain live.
filesystem.grep from the palette onto the canvas. In Properties: Query → TODO|FIXME · Output Key → todosgit.status to the right of the grep node. In Properties: Output Key → git_state · Condition → todos:matches not_empty.IF corner badge — it is now a decision point, not just a step.git.log node. "If TODOs exist, review the commit history."filesystem.tree node. "If the codebase is clean, just show the structure."⬦ if: todos:matches not_empty. The two targets sit above and below the IF node — a diamond fork.
git.log branch lights green; filesystem.tree dims to 18% opacity (not taken)filesystem.tree executes; git.log stays dim"Green edge — condition met, path taken. Amber edge — not met, path skipped. The graph makes the contract visible. No code change required to read it."
Click Agents in the nav. The Fleet sub-tab shows the 4 built-in agents: filesystem, git, shell, system — each with capability badges and health status (ONLINE).
delegate_to: git pointing to git.log. The git agent's tool filter confirms it owns git.* tools. Result: a formatted commit log.
"You can talk to specific agents by name. Each agent has a scoped tool filter — the git agent can only touch git tools. The system enforces that at execution time."
Click the Communications sub-tab inside the Agents view.
The left panel shows a real-time SVG graph of every inter-agent message exchanged during your session:
Click ⤢ Expand in the graph header for a fullscreen overlay — 96 vw × 90 vh, with scroll-to-zoom and drag-to-pan.
"This is a live map of how the agent fleet is coordinating. Every arrow represents a real message passed over the agent bus — not a diagram someone drew by hand."
Tip: run a couple of delegation prompts in 5b before showing this panel — the graph is more impressive with multiple edges already populated.
Stay in the Neural Link (Chat tab). Type one of the following generation phrases — the heuristic parser recognises them instantly and routes to the NL Chain Generator, bypassing the normal planning loop entirely.
create a chain → intent generate_chainchains.db and a result card appears with Open in Studio and View Chains buttons"You described it. Machina OS built it. One sentence — a fully wired, versioned, executable workflow chain ready to run or edit."
More generation phrases to try (all work identically):
Open Studio (Ctrl+6). In the toolbar you'll see the ✨ Generate button alongside Execute, Debug, Auto-Assign, and Optimize.
Daily Standup) and type the description:∥ parallel)IF corner badgegit.* tools → git agent)"Describe it. Build it. The canvas speaks the same visual grammar as a hand-crafted chain — because it is one. Auto-assign agents, hit Execute, or step through with the debugger. The generated chain is version 1 — edit it like any other."
The same engine is exposed as a REST endpoint. Run this from a terminal while the demo is open:
curl -X POST http://127.0.0.1:8100/workflow-chains/generate \
-H "Content-Type: application/json" \
-d '{"prompt": "Generate a workflow that runs daily: list processes, check disk, and save a status note",
"name": "Daily Ops Auto"}'
A full chain record: id, name, version: 1, steps array with tools, agents, output keys, and arguments — ready to execute or wire into CI/CD. Switch to Studio, click Open, and the generated chain loads onto the canvas in one click.
"Any system that can make an HTTP call can generate a chain on demand — no human in the loop, no UI required. Describe it, build it, run it."
Click Agents in the nav → Pipelines sub-tab → Webhooks. The create form has three fields:
Click Create Webhook. A card appears instantly showing:
Copy the trigger URL from the card, then fire it from a terminal:
curl -X POST http://127.0.0.1:8100/webhooks/{chain_id} \
-H "Content-Type: application/json" \
-d '{}'
{"status": "running"} immediately"Your CI/CD pipeline just triggered a security audit. No polling, no agent running 24/7, no Machina UI open. One POST — the chain runs, the results are stored, the audit trail is complete."
When you create a webhook with a secret, Machina OS stores a one-way hash — the plaintext is never saved. A caller authenticates by computing an HMAC-SHA256 digest of the request body and including it in the X-Machina-Signature header:
BODY='{"overrides":{}}'
SIG=$(echo -n "$BODY" | openssl dgst -sha256 -hmac "your-secret" | awk '{print $2}')
curl -X POST http://127.0.0.1:8100/webhooks/{chain_id} \
-H "Content-Type: application/json" \
-H "X-Machina-Signature: $SIG" \
-d "$BODY"
403 Forbidden — chain does not execute"Chain executions from external systems are first-class — authenticated, logged, and visible in the same audit trail as manual runs. Nothing happens in the shadows."
The online demo runs in DEMO mode — a deliberate read-only sandbox. If you try a blocked action, MachinaOS returns a clear DEMO_TOOL_BLOCKED error — not a silent failure.
| Blocked action | Reason |
|---|---|
filesystem.write_file |
Shared workspace — writes would leak between sessions |
shell.run |
Arbitrary command execution on a remote server |
process.stop |
Would kill other visitors' sessions |
git.push, git.commit |
No write access to the repo |
| LLM settings changes | Shared GPT-4o-mini config for all sessions |
All of these work in the live sandbox — pick any and run them in the Neural Link.
| Prompt | What it demonstrates |
|---|---|
Show disk usage |
system.disk — real server metrics |
List running processes |
process.list — live process table |
Read the users API |
filesystem.read_file — syntax-highlighted source |
Search for email addresses in the code |
filesystem.grep + regex pattern matching |
What is the git status? |
git.status — branch, staged/unstaged files |
Show recent commits |
git.log — formatted commit history |
What can Machina OS do? |
Conversational LLM answer with tool catalog |
Show memory usage |
system.memory — available/used GB cards |
Create a chain that checks for secrets and credentials in my codebase |
NL Chain Generation — "Describe It, Build It" — auto-builds a multi-step secret-scan chain |
Build a morning briefing chain: check system health, git status, and recent logs |
NL Chain Generation — 3-step startup chain generated from plain English |
Generate a workflow that runs daily: list processes, check disk, and save a status note |
NL Chain Generation via Neural Link — chain persisted to chains.db, opens in Studio |
"What you're seeing is Sprint 86 — 2273 passing tests, a full runtime contract layer with state-machine-guarded task and step transitions, an AES-256-GCM secrets vault, a SOC 2-compatible audit log, a Tauri 2 desktop shell that ships as a zero-prerequisite MSI, a visual Studio with conditional diamonds, parallel swim lanes, and live debugger stepping, NL Chain Generation that turns a single sentence into an executable pipeline, and a Webhook engine so any external system can trigger your chains via HMAC-signed HTTP POST. The hosted demo intentionally runs in a read-only sandbox so you can explore safely. The full system runs locally — no data leaves your machine."
For live walk-throughs — run through this before starting.
code-review template, execute, show live node animation and summary bannerfilesystem.grep onto canvas, set Query to password|secret|passwd, draw edge, executeask agent git to show the project history — delegation to git agentCreate a chain that checks for secrets and credentials in my codebase in Neural Link — chain generates in seconds, result card shows Open in Studio and View ChainsPOST /workflow-chains/generate curl call for API-first integrationscurl -X POST .../webhooks/{chain_id} from terminal — chain runs, appears in execution historyOpen the live demo in a new tab and follow the storyboard — or just start typing.