OpenCode for Blender and Godot: creating a 3D character from references

OpenCode for Blender and Godot helps establish a workflow in which an AI agent receives access to the project and application tools through MCP, creates a rough 3D model from references, and transfers it to a game project. The result should be checked in Blender and Godot: generation does not guarantee an exact resemblance or a character ready for use in a game.

Described below is one experiment by the author using OpenCode and the GPT 6.1 Soul model. The agent created components for Blender and Godot projects, after which the author opened the Godot scene and inspected the imported result. This experience demonstrates one possible workflow but does not promise the same result on another computer, with another model, or with a different set of tools.

Prepare a folder with the character references

References define the appearance that the agent should take into account during modeling. Gather the images in a separate project folder and choose materials in which the character is visible from different angles or the body parts are clear enough to distinguish. If an image shows only the face, the agent will have to infer the body proportions, clothing, and details that are not visible.

Before launching OpenCode, decide which images should be treated as primary and which should be used as additional guidance. Name the files so their purpose is clear, for example by indicating the angle or character part. Check that the agent can actually see the files in the selected folder: access to the project does not mean that the model has correctly recognized every image or interpreted contradictory references consistently.

The more precisely you separate essential features from secondary ones, the easier it is to evaluate the result. Mark the silhouette, proportions, clothing, color accents, and distinctive details separately. A reference serves as a guide, not a guarantee of exact reproduction.

Formulate a prompt for the 3D project

The prompt for Blender and Godot should describe the goal, source images, work stages, and method for checking the result. In the author’s experiment, the English-language request included the agent’s role, the references folder, the style of the game world, the character’s body parts, the project structure, and a final checklist.

Specify that the images should be studied and a plan prepared first, followed by the step-by-step creation of the model. Ask the agent not to replace the character with an arbitrary similar object: it should compare the silhouette and key details with the source materials. If the project is intended for a game, state this explicitly and ask the agent to preserve an editable scene rather than only producing a final image.

• Goal. Create a rough character for a game project.
• Sources. Name the references folder and explain which images have priority.
• Appearance. Describe the silhouette, proportions, clothing, materials, and noticeable features.
• Workflow. First create the basic form, then the details, materials, and export.
• Verification. Compare the model with the references and check the import in Godot.

Ask the agent to save intermediate versions and report which files it created or changed. This makes verification easier: if the model deviates from the reference, it is easier to return to a specific stage than to analyze the entire project again. Do not instruct the agent to indiscriminately overwrite source images or important scenes.

Which MCP tools and skills may be needed

MCP connects OpenCode to external tools, while skills give the agent instructions for a specific workflow. In the experiment, the author requested recommendations for integrations for Blender, Godot, and project setup. The response suggested Blender Lab MCP, another MCP for Blender, Godot MCP, and Context7, while among the skills the author saw Blender-Godot pipeline.

This list describes the specific setup used in the experiment, not a mandatory package for every user. MCP servers differ in capabilities: one set of tools may control a Blender scene, while another may launch Godot and read error messages. Before installing anything, check the project repository, requirements, permissions, and which actions the server will be able to perform on your files.

Do not install all the extensions you find at once. Choose tools suited to the task and first check that OpenCode can see their commands and that the server connects to the required application and project. If an integration requests broad permissions to access files or execute code, assess whether those permissions are necessary before launching it.

Configure OpenCode to work with the project

Open in OpenCode the folder where the project files should be stored and select a model available in your configuration. Then check the connected MCP servers and skills. The interface and available actions may depend on the OpenCode build and the selected launch method, so rely on the installed version rather than someone else’s screenshot.

Before creating the scene, make sure the agent is working with the correct folder. Ask it to briefly list the available references and describe its work plan without creating any files. This preliminary step helps identify access errors, an incorrect path, or a misunderstanding of the task before the agent changes the project.

If the plan is suitable, allow the project to be created and ask the agent to mark significant changes. Monitor actions that affect existing scenes and files. OpenCode helps with the project, but the developer still needs to check the created resources, imports, and code.

Create the character step by step

Start with a simple blockout: basic forms that define the overall silhouette and proportions. Do not move on to small details until you have compared the height, torso width, and position of the head and limbs with the references. If the main form is wrong, additional elements will only make it harder to correct.

After checking the blockout, instruct the agent to add distinctive details and materials while keeping the scene structure editable. Ask it to show the intermediate result and explain which features from the reference it has already taken into account. In the author’s experiment, the resulting character did not fully match the source images, so it was evaluated as a draft for further refinement.

Completion of the generation does not prove the quality of the model. Open the scene in Blender, inspect the character from several angles, and check that the main parts exist as expected. If the agent created project files, check their names and locations, and save the original version before making significant changes.

Compare the model with the references

Checking correspondence begins with noticeable features rather than fine details. Compare the overall silhouette, proportions, and placement of distinctive elements. Then check the color, clothing, and shape of individual body parts. Record differences between the reference and the model specifically—for example, “the shoulders are wider,” rather than simply “the character looks wrong.”

What should you do if the agent missed an important detail? Name the specific discrepancy and ask it to fix only that issue without changing the parts that already fit. Inspect the scene again after each such step. Iterative corrections provide more control than repeating a general request such as “make it look similar,” which can lead to unpredictable changes.

If the folder contains several images, check the model against each one, taking the viewing angle into account. One view does not always reveal the shape from the back or side. When the references contradict one another, tell the agent which source has priority for the specific feature.

Export the character to Godot

After checking the model, instruct the agent to prepare the export and transfer the resource to the Godot project. The format and contents of the exported data depend on the scene and project settings, so do not rely solely on the agent’s message that the process completed successfully. Open the created project in Godot and check that the scene loads and that the character is present as intended.

In the described experiment, the author opened the Godot scene and checked the imported result. This confirms that, in that specific scenario, it was possible to go from references through Blender to a game-engine scene, but it does not indicate that the character is ready for a full game. For a production game asset, scale, materials, scene structure, and the model’s suitability for further use should be evaluated separately.

If the model does not appear or looks different from the Blender version, check the file path, whether the exported resource exists, and the messages in Godot. Give the agent the exact error text and ask it to diagnose the cause without deleting the materials already created. Re-exporting makes sense after determining exactly what was not transferred.

What worked and what needs refinement

According to the author’s assessment of the experiment, OpenCode together with GPT 6.1 Soul successfully created a project with Blender and Godot components. The resulting model did not fully match the reference, but it worked as a basis for subsequent manual or agent-assisted refinement. This is the result of one practical scenario, not a comparative model test or a guarantee that a finished game character can be created automatically.

The main limitation of this process is already apparent at the comparison stage: text descriptions and images do not replace artistic review. The agent can assemble a scene and export a resource, but anatomical accuracy, style, and the model’s suitability for a particular game require separate evaluation. The time and amount of refinement depend on the quality of the references, the complexity of the character, and the available tools.

How to improve the result through iteration

Divide the corrections by purpose. First adjust the silhouette and proportions, then the clothing and distinctive elements, and afterward the materials and export preparation. For each stage, define a verifiable result and ask the agent not to change the other parts unnecessarily.

1. Save the original draft before changing the model.
2. Name one or more specific discrepancies from the reference.
3. Ask for a limited correction and have the agent report which files changed.
4. Check the scene in Blender, then repeat the export and inspection in Godot.
5. If the error persists, attach an exact description of it and ask the agent to propose a correction plan first.

The overall approach is simple: references set the direction, the prompt describes the stages, MCP connects OpenCode to the tools, and checking in Blender and Godot shows what was actually produced. Use the model as a draft and as an assistant for routine tasks; make the final decision about the quality of the game character only after inspecting the scene and verifying the import.