MCP Alpha

# mcp

The agent talks. The app renders.

MCP is Model Context Protocol — the pipe your AI coding agent uses to call other software. 360 Hextile ships hextile-agent: a stdio MCP server plus one skill. The agent does not scrape the GUI. It does not get a second config language. It calls the same Workflow you would run in the studio.

Merge, validate, and render stay in the running app on your NVIDIA GPU. The plugin is a thin python3 proxy to 127.0.0.1:8000 — stdlib only, zero pip. That loop is the factory face: a world is a build artifact, not a one-off click. This is not the in-app Copilot.

github.com/ansonphong/360-hextile-agent is the package repo — public, MIT, 20 tools. It installs from the ansonphong/360-hextile-plugins marketplace.

# your AI coding agent
  Claude Code  ·  Codex  ·  Grok
           │  MCP stdio
           ▼
     hextile-agent
           │  HTTP 127.0.0.1:8000
           ▼
  360 Hextile (must be running)
           │  NVIDIA CUDA
           ▼
  .hextile.json  →  files on disk

# install

Add the plugin

Three hosts, one plugin, from the 360 Hextile marketplace ansonphong/360-hextile-plugins. The studio-matte plugin hextile-pipe ships from the same marketplace. A local checkout still works — swap the slug for a path.

# 1 · add the marketplace
/plugin marketplace add ansonphong/360-hextile-plugins

# 2 · install the plugin
/plugin install hextile@360-hextile

# public marketplace
$ grok plugin marketplace add ansonphong/360-hextile-plugins
$ grok plugin install hextile --trust
# enable hextile in /plugins or config.toml

# Codex ≥ 0.34.0
$ git clone https://github.com/ansonphong/360-hextile-agent.git
$ cd 360-hextile-agent
$ python3 codex/install.py
# installer writes sys.executable as the Codex command
# restart Codex → /mcp → hextile

$ python3 codex/install.py --uninstall

# agent-mode

Opt-in MCP follow. Default OFF. This is not Copilot Auto. Turn it on in Help + Settings. Then the running studio follows the local agent's render work so you can watch the same job in the app. Leave it off and the factory stays headless: the agent calls tools; you watch from the agent.

agent calls run_workflow  →  local MCP  →  360 Hextile queues render
                                                     ↓
                          AGENT MODE (opt-in, default OFF): studio follows it

It follows local work on the running app. Take control stops the follow. Cancel stops the GPU. It does not add cloud rendering, unattended remote control, or a public agent service. This is not in-app Copilot.

# first-run

Point the agent at a Workflow

Launch 360 Hextile first. Then: list → get → validate → run → status. Send workflow_id + overrides. The app owns merge and validation. Arrays replace wholesale — they do not append.

1. 1 listlist_workflows — shelves are builtin (immutable), user, project.
2. 2 getget_workflow on a builtin such as quick-scout. A Workflow is a full .hextile.json.
3. 3 validatevalidate_config is the same run endpoint with dry_run: true. Send the overrides you intend to run.
4. 4 runrun_workflow queues the GPU job. Live runs need a non-empty input.path.
5. 5 statusPoll get_status until completed / failed / cancelled / crashed.

## recipe A · scout from a builtin

# quoted from hextile-agent recipes
get_capabilities
get_guide(name="best-practices")
list_workflows
get_workflow(origin="builtin", id="quick-scout")
validate_config(workflow_id="quick-scout", origin="builtin", overrides={
  "prompt": {"global": "<user look>"},
  "input":  {"path": "<existing equirect file>", "source": "file"}
})
run_workflow(same)
get_status(run_id)

quick-scout ships with an empty input path. A live run needs a file, or a seed from recipe B. Poll get_status until completed, failed, cancelled, or crashed. Lost the id? list_runs. Abort with cancel_run.

## recipe B · 360 LoRA seed, then run

# Pattern and 360 LoRA are INPUT — a seed the pipeline consumes
list_360_loras
generate_seed(prompt, lora_path, base_model, n=4)
# base_model: sdxl | sd15 | flux_schnell | qwen_image
# pick variations[0]
run_workflow(workflow_id="quick-scout", overrides={
  "input":  {"path": "<variation path>", "source": "file"},
  "prompt": {"global": "<look>"}
})

Never write retired source types into render-time input.source. Persist a variant with save_workflow on the user or project shelf (create-only; builtin is immutable; 409 means pick a new id).

# tools

What the agent can call (20)

Quoted from the package README. The app is the system of record. These names proxy HTTP. Knowledge lives in get_guide.

Not in this plugin: Pattern generate, gallery publish, in-place workflow UPDATE, batch fan-out. Do not invent those tools.

# rails

Requirements

• 360 Hextile must be running on this machine. MCP talks to the local process, not a cloud queue.
• python3 ≥ 3.9 on PATH. Zero pip packages. The proxy is stdlib only. On Windows, Claude .mcp.json command should be python or py -3, not python3.
• App build with POST /api/workflows/run. Older builds return an upgrade error.
• Windows + NVIDIA CUDA — a requirement, not a preference.
• Local, offline, perpetual. One payment. Nothing is uploaded to a 360 Hextile render queue.
• If a tool says the app is down, the MCP process stays up. Tell the user: Launch 360 Hextile, then retry.

# curl

No python3? Hit the API

The skill documents a curl fallback. Same endpoints. Same machine.

$ curl -s http://127.0.0.1:8000/api/workflows
$ curl -s -X POST http://127.0.0.1:8000/api/workflows/run \
    -H 'Content-Type: application/json' \
    -d '{"workflow_id":"quick-scout","origin":"builtin","dry_run":true}'