Hire an AI Godot multiplayer designer

Everything it can hand back

Your task sets the actual outputs. The specialist picks the methods that cover them.

• An authority table that says who owns each piece of state
• A sync plan for spawning and for the properties each node shares
• An RPC list with who calls it, who runs it and what the server checks
• A connect, lobby and leave flow
• Draft code for the parts you ask for, marked as not run
• A test plan with lag, bad input and rejoin, for you to run

How it does the job well

• The server (peer 1) owns all state that matters to play: position, health, score, item state. Set authority on purpose. Do not rely on the default.
• Guard every change to replicated state with an authority check.
• Clients send requests by RPC. The server checks them and then changes the state.
• An RPC that any peer may call must validate the sender and the values inside the function. Never let a client-callable RPC change game state without a server check.
• RPC modes: "any_peer" for client-to-server requests the server validates, "authority" for server-to-client confirmations, "call_local" when the caller should also see the effect. Important events use reliable calls.
• Start from the user's task and the content, then the layout. Decoration comes last.
• Design every state: empty, loading, error, long text and mobile.

Mistakes it avoids

• Letting any peer change state with no server check.
• Adding networked nodes by hand with add_child.
• Syncing every property "just in case".
• Declaring it done after a test on one computer with no lag.
• Designing only the happy path at desktop width.
• Copying a reference's logo, text or claims instead of learning from its structure.

What a good result looks like

An example, not your task: You are starting a Godot 4 multiplayer game and need to decide who owns what before you build.

• Authority table. Each piece of state with its owner and how others may ask to change it.
• Replication plan. How each scene spawns on every peer and which properties it syncs.
• RPC list. Each remote call with its mode, caller, runner and the checks the server makes.
• Connection and lobby flow. The steps for hosting, joining, leaving and rejoining a game.
• Draft code. Server setup, spawning and RPC code you asked for, marked as not run.
• Test plan. Lag, bad input and rejoin tests, each with what a pass looks like.

How the work is checked

• Every screen has its states, breakpoints and interactions written down.
• Colour pairs and type sizes pass the stated contrast checks.
• The handoff names components, tokens and open questions.
• States which checks passed, failed or could not run, and names missing inputs.

These checks have not been run against a model yet. Your AI uses them to check its own work.

A second opinion

Before it hands back, your AI reviews the draft the way Linus Torvalds and Warren Buffett would. This is a way of reviewing the work. It does not mean they wrote or endorse it.

Capabilities

• Set the scope. It states the game type, player count, topology and version. It asks once for what is missing and marks the rest.
• Build the authority table. It lists each piece of state, the peer that owns it and how others may ask to change it. The server owns anything that matters.
• Plan replication. It plans how nodes spawn on every peer and which properties sync. It uses on-change sync for anything not driven by physics.
• Plan the RPCs. It lists each RPC with its mode, who may call it and what the server checks. Any call open to every peer is checked by the server.
• Plan the tests. It plans tests for lag, impossible values, calls to the wrong peer, and a dropped player rejoining.

How the role works

1. Checks your task, context and available tools.
2. Picks the methods needed and prepares a work plan.
3. Carries out supported tasks, with each method's limits and review gates.
4. Checks the real deliverables and corrects supported faults.
5. Hands back files, evidence and unresolved gaps.

Your specialist's working setup

Download the base specialist without a task form or account. README.md and SETUP.md explain how to use the folder. SOUL.md defines its scope. INTAKE.md asks missing questions inside your AI. PLAYBOOK.md, SKILLS.md, BEST_PRACTICES.md, CHECKS.md and HANDOFF.md guide the work and its checked deliverables.

Complete associated skills, supporting files and licences are included. Choose only the methods needed for the actual task. Keep context, working files and accepted feedback in your AI project.

Use this specialist through MCP or the API

Call prepare_specialist with role_id godot-multiplayer-engineer only. No task is required to load it. Your AI asks what job you need done, what you want back and which relevant context it can use.

For task-led hiring, call find_specialist, explain the suggested specialists and let the user accept or change the team.

Complete ZIP: Download base specialist. API: GET /api/v1/specialists/godot-multiplayer-engineer/pack. The host AI supplies its own model, tools and execution; a pack does not connect accounts or run a task.

Inputs and helpful context

The specialist starts from the task brief. Only active methods require their inputs.

For the primary method, when used

• The game type, how many players it must hold and whether one player hosts or a server runs it
• Your Godot version and whether players play on desktop, phone or the web
• The state that must be shared, such as position, health, score or items
• Your scene and script files for the networked parts, pasted as text (optional)
• What goes wrong today, if anything (optional)

Helpful context (optional)

• A short description of what a bad session looks like, so the plan targets it.
• The target platforms, since web games need a different connection method than desktop games.

Tools and access

• Claude, ChatGPT or Gemini with file upload: It can read your scenes and scripts together and find nodes that sync a property without an owner.

Functions and deliverables

• Godot multiplayer designer: Plan Godot 4 multiplayer with the server owning key game state, the right synced properties and RPCs, and tests to run before cheating or lag breaks it.
  • An authority table that says who owns each piece of state
  • A sync plan for spawning and for the properties each node shares
  • An RPC list with who calls it, who runs it and what the server checks
  • A connect, lobby and leave flow
  • Draft code for the parts you ask for, marked as not run
  • A test plan with lag, bad input and rejoin, for you to run
  Source: Michael Sitarzewski and Agency Agents contributors.
• Event key moment designer: Plan an event people remember. Get the one peak worth building, the expected step to break and a plan with owners, dates and costs.
  • The one peak to build, with the reason it was picked
  • The expected step you will break, and what happens instead
  • One lift, one proof of progress or insight, and one link to others or to your purpose
  • A plain, cheap version of every other step
  • Who does what, by when, at what cost, and any basics to fix first
• Bad-year break-even tester: Share profit, exposure and cash-flow figures. Get break-even stress sums, risk evidence and gaps, without a forecast guarantee.
  • A list of events with how likely each is and why
  • A break-even sum for the worst likely event
  • A survival check against cash and debts
  • A list of risks that cannot be priced
  • A call of holds, thin or fails, and the fact to watch
• Breaking change reviewer: Share a planned change and usage evidence. Get affected groups, compatibility gaps, a custom checklist score and a safer rollout proposal.
  • Each group of users the change touches and what breaks for them
  • A score out of 100 for how safe the change is, and how it was worked out
  • What to keep, and what to do with any empty leftover options
  • A fix-on-report path, a revert path and a one-sentence verdict
• Brand profile builder: Share your website. Get a reusable profile covering your products, customers, voice and approved claims, with sources.
  • A folder of eight plain files, from a start file for your AI to a claims list and a change log
  • A tag on every fact, and every claim marked approved, pending or banned
  • A two-sentence diagnosis of your biggest gap, and a list of what's missing and who can answer it
  • A short slice for your next step, if you name one
• Linus Torvalds: Review a code change using Linus Torvalds’s recorded approach. Ask what works, what breaks for existing users and who owns the fix.
  • Your problem worked on the way Linus Torvalds would: their questions, their method, their push-back
  • The answer or the work, in Linus Torvalds's voice, using their ideas by name
  • Anything that goes beyond their public record, marked
  • One suggested next step
• Warren Buffett: Review a business using Warren Buffett’s recorded principles. Check how it earns, what protects it, how managers use cash and which facts remain uncertain.
  • Your problem worked on the way Warren Buffett would: their questions, their method, their push-back
  • The answer or the work, in Warren Buffett's voice, using their ideas by name
  • Anything that goes beyond their public record, marked
  • One suggested next step

Tasks you can use it for

• You are starting a Godot 4 multiplayer game and need to decide who owns what before you build.
• Players see different things, or objects jump, or a player's actions are ignored.
• You want to stop clients from cheating by sending fake positions or damage.
• You need a lobby and connect flow, with join, leave and rejoin handled.

Limits to check before starting

• You are scripting single-player gameplay, such as health or an inventory. Use the Godot gameplay programmer.
• Your game is in Unity or Unreal. Use the Unity Multiplayer Engineer agent or the Unreal multiplayer designer.
• You need to host servers, pay for them or plan scale. Use the Backend Architect agent.
• You want a review of a live server under load. A plan cannot replace a load test you run.

Best way to use this role

Give it one clear outcome, the actual files and a definition of done. Keep the work in one AI project so it can reuse checked context and earlier files.

• Download the pack and add it to your AI as a skill. If you cannot, paste SKILL.md and then references/source-agent.md into a new chat.
• Describe the game, the player count, your Godot version and the state that must be shared. Paste the scripts for your networked nodes if you have them.
• Type "Plan the authority model and RPCs, then draft the server setup." Your AI asks once for anything missing.
• Read the authority table first. Every row must have one owner. Fix any row that says "both".
• Test with two game windows on your computer, then add 100 to 200 milliseconds of lag with a tool you choose. Your AI cannot run these tests.
• Try bad input, such as an impossible position sent from a client, and check the server refuses it.

Read it as data

Read the complete role setup as JSON. Connect your AI to the AI Blocks MCP library and read aiblocks://roles/godot-multiplayer-engineer for its role instructions and pinned sources.

This is a prepared AI role. No task has run. Your AI carries out authorized work using its available tools and reports the actual deliverables and checks.