StealthDraft

• 

• 

• 

• 

• 

• 

• 

• 

Inspiration

AI agents are becoming increasingly capable of reasoning about complex creative work, but professional visual editors are still difficult for them to operate reliably.

A traditional computer-use agent must interpret pixels, guess which visual object corresponds to which underlying domain object, estimate positions, and manipulate a spatial canvas through fragile clicks and drags. A layout shift, zoom change, or misread label can turn a simple edit into the wrong mutation.

I wanted to explore a different model:

What if a professional creative tool exposed its real structured state and domain operations directly to an AI agent?

That idea became StealthDraft.

StealthDraft explores a future where the AI does not imitate a mouse. Instead, the human and the agent operate on the same live design document through structured domain tools.

What it does

StealthDraft is a WebMCP-native tactical mission design workstation for human + AI collaborative level design.

A human designer works visually on an AEGIS-CAD-style tactical canvas containing rooms, corridors, security areas, server areas, mission entities, and bidirectional routes.

An AI agent works on that exact same mission through WebMCP Site Tools.

There is no second hidden agent representation of the level.

Both sides operate on the same centralized mission state.

The final production version exposes 11 WebMCP Site Tools:

get_mission_state, create_room, update_room, delete_room, place_entity, create_connection, delete_connection, update_entity, delete_entity, validate_mission, and analyze_mission.

The agent can inspect an existing human-authored mission, construct new missions from an empty canvas, make targeted edits, diagnose structural failures, repair them, validate the result, and now analyze structural resilience.

Why WebMCP

StealthDraft is built around the idea that WebMCP should be a real product interface for the agent, not just an additional integration badge.

Without WebMCP, an agent would need to visually locate rooms, estimate coordinates, find connection handles, and manipulate a canvas designed for human input.

With WebMCP, the agent instead receives typed mission state with stable IDs and calls explicit domain operations.

The agent does not scrape the canvas.

It reads the graph, mutates the graph, validates the graph, and analyzes the graph.

The human UI and the WebMCP Site Tools share the same Zustand mission store and the same domain mutation logic. Human and agent are therefore genuinely collaborating on the same document.

This architecture also means agent behavior is much easier to test and verify than pixel-driven canvas automation.

Deterministic mission validation

StealthDraft includes a deterministic TypeScript mission validator with seven fixed structural checks:

STATE_INTEGRITY
SPAWN_EXISTS
OBJECTIVE_EXISTS
EXTRACTION_EXISTS
SPAWN_REACHES_OBJECTIVE
OBJECTIVE_REACHES_EXTRACTION
NO_ISOLATED_CRITICAL_ROOM

Validation does not use an LLM.

Both the human Validate action and the WebMCP validate_mission tool use the same deterministic validation engine.

Checks return pass, fail, or skipped, allowing an agent to understand not only that a mission is broken, but why.

Connections are modeled as bidirectional for structural analysis. Locked routes are currently a design-level classification; structural validation treats locked and normal routes as traversable, and keycard inventory/access gameplay is not simulated.

Mission Intelligence

Validation answers:

Does this mission structurally function?

But a mission can be valid and still be fragile.

That led to the second deterministic engine in StealthDraft: Mission Intelligence.

The new read-only analyze_mission WebMCP tool performs deterministic topology analysis over the current mission graph.

It calculates required shortest paths, hop counts, ordered room and connection paths, locked links on the selected shortest path, structural single points of failure, and single-link fault tolerance.

The same analyzeMission() implementation powers the human-facing Topology Diagnostics UI.

Mission Intelligence does not use an LLM and does not produce a subjective level-design score.

It does not claim to measure fun, pacing, stealth difficulty, or whether a mission is “good.”

It measures graph structure.

That distinction became one of the main product principles of StealthDraft:

VALID ≠ RESILIENT.

A mission can pass all seven validator invariants while still containing structural single points of failure.

Human + Agent collaboration

StealthDraft is built around a collaborative loop rather than autonomous replacement.

A human can author or modify the graph manually.

The agent can then inspect the live state through WebMCP, reason about the structure, and perform bounded domain mutations.

Every actual mutation is visible in the Activity history and attributed as either HUMAN or AGENT · WEBMCP.

Read-only operations such as validation and analysis do not pollute the Activity log.

The result is an auditable workflow where the designer can see exactly what the agent changed.

What we proved

All major workflows were tested with real ChatGPT Site Tools rather than only mocked tool calls.

Autonomous construction

Starting from an empty mission, ChatGPT created a complete stealth mission using only StealthDraft Site Tools.

It created rooms, placed the required Spawn, Objective and Extraction entities, added enemies and a keycard, connected the mission graph, and reached 7/7 deterministic validation.

Single-fault repair

A human manually removed one critical mission connection.

ChatGPT inspected the current graph, ran deterministic validation, identified the reachability failure, restored exactly one targeted connection, and returned the mission to 7/7 PASS without moving the human-authored rooms.

Iterative multi-fault repair

A human removed both the Objective and a critical connection.

The agent first detected the missing Objective and restored it.

After revalidation exposed the next structural failure, the agent restored the missing route and validated again.

The mission returned to 7/7 PASS using exactly two targeted mutations, while preserving the human-authored layout.

Proactive structural hardening

Mission Intelligence introduced a new workflow that does not begin with a broken mission.

The built-in sample mission already passed validation at 7/7, but analyze_mission found 4 critical connections.

The agent then created exactly one targeted interior bypass:

Service Corridor ↔ Server Room

Re-analysis showed:

Critical connections: 4 → 2

Spawn → Objective depth: 3 hops → 2 hops

The mission still passed 7/7 validation.

The agent did not rebuild or reposition the mission. It improved the existing topology with one bounded mutation.

This moves the workflow beyond reactive error repair toward proactive design hardening.

Extended chapter-scale stress test

I also tested the final system with a substantially larger autonomous construction task.

From an empty canvas, without using Load Sample, ChatGPT created a chapter-scale mission containing:

14 rooms, 11 entities, 19 connections, 6 enemies, 2 keycards, and 5 locked-design routes.

The graph contained named spaces, multiple branches, reconnection points, separate infiltration and extraction regions, and a protected objective area.

The agent first reached 7/7 validation, then called analyze_mission, identified structural weaknesses, and applied up to three targeted hardening connections.

The final deterministic analysis reported:

Spawn → Objective: 5 hops

Objective → Extraction: 2 hops

Critical connections: 0

Spawn → Objective single-link fault tolerant: true

Objective → Extraction single-link fault tolerant: true

Final validation: 7/7 PASS

This does not prove that the generated chapter is fun or optimal.

It demonstrates that a structured WebMCP interface can support chapter-scale mission-graph construction, deterministic validation, analysis, and iterative hardening.

How it was built

StealthDraft is a client-side web application built with React, TypeScript, Vite, Zustand, React Flow / XYFlow, Vitest, and WebMCP.

The mission domain lives in one centralized Zustand store.

React Flow renders that state as the human-facing tactical canvas.

WebMCP handlers operate on the same store and reuse the same domain actions.

Two deterministic read-only engines operate on the mission graph:

validateMission() performs the seven structural validation checks.

analyzeMission() performs Mission Intelligence / Topology Diagnostics.

WebMCP tools are registered through document.modelContext with structured schemas, explicit tool descriptions, and deterministic result/error contracts.

No external LLM API is embedded inside StealthDraft. The AI agent comes from the WebMCP-enabled client environment.

The interface is desktop-first but also includes a responsive mobile workstation layout tested on a real Android device.

Challenges

The hardest part was not exposing UI buttons as tools.

The real challenge was designing an agent-facing domain surface that remains predictable under repeated autonomous use.

That required stable IDs, safe destructive operations, structured errors, idempotent duplicate connections, bidirectional graph semantics, PATCH-style updates, deterministic validation, deterministic topology analysis, malformed-state handling, secure-context-safe ID generation, read-only guarantees, and stale-result protection in the human UI.

Another major challenge was keeping the semantics honest.

For example, locked connections are visually meaningful design classifications but are not currently simulated as inaccessible gameplay routes. Keycards exist as mission-design entities, but possession and access-control logic are intentionally not simulated.

Mission Intelligence required the same discipline: it measures structural resilience, not subjective design quality.

What's next

The hackathon version focuses deliberately on the mission graph itself.

Future versions could extend StealthDraft with richer stealth systems such as patrol routes, cameras and detection coverage, deeper access-control mechanics, mission templates, versioned import/export, reversible agent checkpoints, and integrations with Unity or Unreal workflows.

Longer term, the idea extends beyond stealth missions.

Many professional creative tools contain rich structured state that AI agents currently try to reconstruct from pixels.

I believe those tools become dramatically more useful when humans and agents can share:

the same state, the same domain operations, and the same deterministic feedback systems.

StealthDraft is an experiment in what that kind of AI-native creative workstation can look like.

Built With

• ai-agents
• chatgpt
• graph-analysis
• react
• react-flow
• typescript
• vite
• vitest
• webmcp
• xyflow
• zustand