The External AI Bridge: How Claude, Cursor, ChatGPT, Gemini and Grok Can Run Your Neyra Studio — And the Neuro Final Draft Protocol They Must Respect

A studio you can drive from any AI

A director should not have to be in any one app to run their film.

That is the architectural conviction behind the External AI Bridge. Neyra Studio exposes a secure MCP server — Model Context Protocol, the open standard for letting AI assistants call external tools — so any MCP-compatible client can act on your behalf:

• List projects
• Edit scenes
• Regenerate images
• Run full auto-produce
• Query the coverage verdict

Claude Desktop, Cursor, ChatGPT custom connectors, Gemini, Grok — all become legitimate remote controls for your studio. You stay in control: every external client uses a scoped token you can revoke at any time, and every heavy operation is audited with timestamp, tool, and token used.

This is what “AI-native infrastructure” looks like when it is taken seriously. Not a plugin marketplace. A protocol.

---

Tokens — the unit of trust

All bridge tokens live under Profile → Bridge. Each token is:

• Bound to your account
• Labeled (“Claude · Studio iMac,” “Cursor · Office”)
• Scoped to a permission level
• Rate-limited separately from your other tokens
• Optionally bound to an expires_at

The scopes:

• Read only — list_projects, get_project, get_scene, get_coverage_verdict, get_netflix_score, list_characters. Perfect for review, audit, planning conversations. Safest possible token.
• Read + write — everything above, plus update_project, update_scene, regenerate_image, improve_prompt, set_emotion_arc. The default for working sessions.
• Full — everything above, plus heavy ops: auto_produce, generate_video, generate_music, generate_voiceover, render_chain. Use only with trusted clients on your own devices.

Two non-negotiable rules:

1. Tokens are shown once. When you create a token the secret appears for a few seconds. We only ever store a hash. We cannot show it again. Copy and store it immediately.
2. Use the lowest scope that does the job. A producer reviewing your film via ChatGPT should hold a read_only token. Only your own development tokens need full.

If a laptop is stolen, you revoke that one token. The rest of your stack keeps working.

---

Connecting the five major clients

Each MCP client has slightly different UI — but the same three pieces of information: server URL, auth type (Bearer), token.

Claude Desktop

Claude reads MCP servers from a JSON config:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Add a neyra entry under mcpServers with the MCP URL from your Bridge tab and an Authorization: Bearer <token> header. Restart Claude (⌘Q). The plug 🔌 icon at the bottom of the chat shows the Neyra tools. Ask Claude “list my Neyra projects” — it should call list_projects and return your titles.

Cursor

First-class MCP support. Settings → MCP → Add new MCP server. Type HTTP/SSE, paste your URL, add the Bearer header. Save and restart. Tools appear in the composer's tool menu. Cursor surfaces them automatically when relevant — which means you can edit a .fountain script in the IDE and, in the same chat, ask the AI to push the new draft into Neyra via update_project_doc.

ChatGPT

Plus / Team / Enterprise → Settings → Connectors → Build a custom connector → paste URL, choose Bearer token, paste secret. Toggle Neyra on per-chat.

Gemini and Grok

Gemini CLI or Code Assist → MCP config → add a neyra server with URL + Bearer header. Grok app → Settings → Tools / Connectors → Custom MCP → paste URL and Bearer header.

MCP support is rolling out continuously. If your client does not yet see the option, update.

---

The tool catalog — versioned and scoped

Neyra's MCP server exposes a curated subset of the internal action registry. Each tool reports its JSON schema to the host AI on connect, so Claude and Cursor read the schema and surface parameter hints in their UI automatically.

The scope of the token gates which tools are visible. Heavy ops are rate-limited in a separate bucket — even a full-scoped token cannot burn all your credits in one minute.

Every call is audited. Profile → Bridge → click a token to see its recent calls: tool name, params summary, status, duration. If something went wrong, you can see exactly what and when.

---

The Neuro Final Draft protocol

Here is the part that matters more than any of the setup above.

Neyra films are not just sequences of clips. They follow a production grammar we call the Neuro Final Draft (NFD) protocol. Every scene declares its place in this grammar. Downstream agents — HARMONIC for music, EDITOR for pacing, ORACLE for QA — read it as their input.

When an external AI edits a Neyra project, it must respect this grammar. Otherwise the downstream agents lose the signal they depend on and the film falls apart in post.

NFD has four primary axes:

1. The 9-tier shot hierarchy

Every scene declares its tier:

• Establishing
• Hero
• Medium
• Close
• Detail
• Macro
• Super
• Transition
• Internal
• Exit

Each tier has a job in the audience's attention curve. Changing a Hero shot to a Detail without updating the tier breaks the rhythm — the editor agent will misjudge cut length, the composer agent will misjudge musical weight.

2. Render mode

• T2V — text-to-video (Sora / Veo). Use for open scenes built from intent.
• I2V — image-to-video (Kling / Runway / LongCat animates a still). Use when you need a specific frame to live and breathe.
• Hybrid — T2V open, I2V close (or vice versa). Use when a shot has two distinct phases.

Declared per scene so downstream agents pick the right model and the right pricing tier.

3. The NeuroBeat vector

Three sliders, 0–10, plus a rhythm profile:

• emotional_temp (cold → hot)
• movement_energy (still → explosive)
• intimacy (cosmic → intimate)
• Rhythm: breath · pulse · flow · tension · burst · ritual

HARMONIC reads this to score the scene. EDITOR uses it to set cut pacing. Without it, music feels random and cuts feel arbitrary.

4. The camera grammar token

A compact structured string per scene:

CAM_PUSH_IN_0.3 LENS_85MM_T1.4 LIGHT_KEY_45L_3200K COMPO_RULE_OF_3 SCALE_MCU

Downstream agents expand this into Runway Director Mode payloads and Veo structured camera payloads. The token is canonical — every renderer reads from the same string.

A fifth element governs sign-off: the ORACLE QA gate. Each scene has a 10-question pass/fail checklist with statuses untested · partial · passed · failed. A scene is not approved until ORACLE gives it a green light. External AIs must not override qa_checklist.status directly.

---

How an external AI should behave

Three rules of citizenship for any bridged client:

1. Read before writing. Call get_scene first. See the existing tier, render mode, NeuroBeat, camera grammar. Then make changes that are coherent with the surrounding scenes.
2. Use the high-level tools, not direct entity writes. update_scene_camera_grammar and set_neurobeat exist precisely so the bridge cannot accidentally break the protocol.
3. Hero Follow links are sacred. If a scene has a hero_follow_out link to the next scene, the protagonist's identity must propagate. Severing the link is almost never what the director meant.

Follow these and the external AI becomes a real extension of your studio — not a tool that beautifies one shot and breaks ten others.

---

Why this is the future of AI-native software

The last twenty years of software shipped plugins. Plugins are closed, vendor-controlled, and assume a single host.

MCP is different. It is an open protocol that assumes the user owns the data, the user owns the tokens, the user picks the client. The vendor's job is to be a good protocol citizen.

Neyra was built MCP-native from day one because the next generation of studios will not run on a single vendor's cloud. They will run on a mesh of services coordinated by open protocols. Your studio. Your tokens. Your client. Our orchestration.

That is the bridge.

— Neyra Engineering