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 public MIT package source. ansonphong/360-hextile-plugins is the public marketplace channel. Check the selected channel for its released tool inventory; the two channels do not always point at the same package revision.

# 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-agent@360-hextile

# public marketplace
$ grok plugin marketplace add ansonphong/360-hextile-plugins
$ grok plugin install hextile-agent --trust
# enable hextile-agent 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

Stable capability groups

Public tool inventories vary by release channel. The running app is the system of record for availability. Start with get_capabilities and use get_guide for live workflow guidance.

This is a capability map, not an exhaustive tool list. Batch workflow tools visible in local APP development are disabled by default and are not part of the released public package or marketplace promise.

# 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}'