# BlenderXAlpha 3DGenSkill

> Agent Skill that turns plain-English scene descriptions into AI-generated 3D models built live in Blender, via Alpha3D + Blender MCP. Works with Claude Code, Cursor, and OpenAI Codex.

- **Type:** MCP server
- **Install:** `agentstack add mcp-ig-shadow-walker-blenderxalpha-3dgenskill`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [ig-shadow-walker](https://agentstack.voostack.com/s/ig-shadow-walker)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [ig-shadow-walker](https://github.com/ig-shadow-walker)
- **Source:** https://github.com/ig-shadow-walker/BlenderXAlpha-3DGenSkill

## Install

```sh
agentstack add mcp-ig-shadow-walker-blenderxalpha-3dgenskill
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Alpha3D Scene Generator for Blender

**Describe a scene in plain English. Your AI agent generates the 3D models with Alpha3D and builds it in your open Blender file, scaled, grounded, and placed.**

An [Agent Skill](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/overview) for [Claude Code](https://claude.com/claude-code), also usable in Cursor and OpenAI Codex, that connects an AI 3D provider ([Alpha3D](https://alpha3d.io) by default, or Tripo or Meshy) to a running Blender session.

**Works with**
&nbsp;
&nbsp;
&nbsp;

_Demo video coming soon._

---

You say:

> *"I've got Blender open on an empty scene. Build me a small fantasy village: a stone well in the center, three different cottages around it, and a wooden cart by the entrance."*

Your agent breaks that into individual assets, shows you exactly what each one costs in Alpha3D credits, waits for your go-ahead, then generates them one at a time, importing each into your live Blender file as it finishes, scaled to a sensible real-world size, dropped to the floor, and arranged into the layout you described. No manual export, download, or import.

## Contents

- [What it can build](#what-it-can-build)
- [Capabilities](#capabilities)
- [How it works](#how-it-works)
- [Prerequisites](#prerequisites)
- [Installation](#installation) (Claude Code, Cursor, Codex)
- [Choosing your 3D provider](#choosing-your-3d-provider) (Alpha3D, Tripo, Meshy)
- [Usage](#usage)
- [Cost](#cost)
- [Repo layout](#repo-layout)
- [Troubleshooting](#troubleshooting)
- [Contributing](#contributing)
- [License](#license)

## What it can build

Point it at your open Blender file and describe what you want in it:

- **A game level or environment:** set pieces, terrain dressing, scattered props.
- **A product or interior scene:** furniture, fixtures, and decor arranged in a room.
- **A character or creature:** generated, and optionally rigged so you can pose it.
- **A tabletop set or diorama:** a themed collection of small props laid out together.
- **Props into a scene you already have:** "add a lamp on my desk", dropped onto the real desk.

You stay in the loop: it always plans and prices the work first, and never spends a credit without your say-so.

## Capabilities

| Capability | What you get |
|---|---|
| **Text, image, or multi-view to 3D** | Generate a model from a prompt, a reference image, or several angles of one object. |
| **Reuse your library, for free** | Refer to a model you already made ("my dragon from last week") and it imports that one instead of paying to regenerate it. |
| **Identical copies for one price** | "Five barrels" generates once and duplicates the rest inside Blender, so the extra copies cost zero credits. |
| **Smart source triage** | Hero props and organic shapes get AI-generated; a flat floor or plain cube is built as a free Blender primitive; atmosphere like sky or fog is skipped. You never pay to generate a cube. |
| **Scene-aware placement** | Reads what is already in your file, so "on my desk" lands on the actual desk. Then it scales each asset to a real-world size, drops it to the floor, and groups it under a named Empty. |
| **Sees the scene** | It does not fly blind. It can view the viewport (your bridge's screenshot, or a quick render it reads back) to understand an existing scene before planning, and to check its own work after, fixing anything that intersects, floats, sinks into the floor, or faces the wrong way. |
| **Layout reasoning** | "Around the well" becomes a circle, "along the path" a line, a loose list a spaced grid, with facing applied where the description implies it. |
| **Refinement passes** | Optional auto-rig, retopology, UV unwrap, re-texture, or part segmentation, triggered from your words ("rig it so I can pose it"). |
| **Concept image to 3D, for free** | Generate a concept image with FLUX first; once you like it, turn that exact image into a model. |
| **Cost-safe by design** | Generates one asset at a time and stops cleanly the moment you run out of credits, never mid-committing a batch it can't finish. Shows a per-asset cost table and waits for confirmation; failed jobs auto-refund; an interrupted run recovers already-paid assets from your library instead of charging twice. |
| **Provider choice** | Generate through Alpha3D (default), or switch to Tripo or Meshy. All return GLB, so the Blender half is identical; you pick at install and can change it anytime. |
| **Fails loudly, not silently** | If Blender is not connected or a model comes back malformed, it tells you what is wrong and how to fix it, rather than producing a cryptic error. |

> [!TIP]
> The cheapest asset is the one you do not generate. This skill leans on reuse, primitives, and duplication precisely so a scene costs the minimum number of real generations.

## How it works

This skill is pure orchestration. It plugs two MCP connectors together and does the scene reasoning in between.

```mermaid
flowchart LR
    U[You describe a scene] --> C[Your coding agent + this skill]
    C -->|generate, poll| A[3D provider MCPAlpha3D / Tripo / Meshy]
    A -->|GLB download links| C
    C -->|execute_blender_code| B[Blender MCP bridgeruns bpy in your Blender]
    B --> S[Your live Blender scene]
```

1. **Your chosen 3D provider's MCP** ([Alpha3D](https://alpha3d.io) by default, or Tripo or Meshy) generates the actual 3D models and handles optional refinement (rigging, retopo, UV, texturing, segmentation).
2. **A Blender MCP bridge** (a Blender add-on that exposes a local `bpy` code-execution tool over MCP) lets the agent import and place assets inside your running Blender instance.

Your agent sequences both: it plans the scene, prices it, and after you confirm, downloads each model to local disk, sanitizes it for Blender's strict glTF loader, and imports it, arranging assets as each one finishes. It can also see the viewport (via a screenshot or a quick render) to understand an existing scene and to check its own work. See [`SKILL.md`](./skills/alpha-scene-gen/SKILL.md) for the full step-by-step procedure.

Example: what actually happens for the village above

Your agent first shows a plan and the cost, and stops:

| Asset | Source | Quality |
|---|---|---|
| Stone well | generate | pbr |
| Cottage (3 different) | generate x3 | pbr |
| Wooden cart | generate | pbr |
| Ground plane | primitive | free |

> This generates 5 models (the well, three different cottages, the cart); the ground plane is a free Blender primitive. Here is the total credit cost and your balance after it. Confirm to build, or tell me what to change.

On your go-ahead it generates them one at a time, checking your balance before each so it stops cleanly if you run low. As each finishes it imports the model, scales it (a well is about 1.5 m, a cottage about 5 m), drops it to the floor, and places it: the well at the center, the three cottages spaced around it in a ring, the cart out by the entrance. It ends with a viewport screenshot and the exact credits actually spent.

## Prerequisites

| Requirement | Why | Notes |
|---|---|---|
| An **MCP capable coding agent** that runs on your machine: **Claude Code**, **Cursor**, or **OpenAI Codex CLI** | Runs the workflow and reaches Blender on your machine | Per-client setup is below. |
| **An account + MCP connector for your 3D provider** (Alpha3D by default; or Tripo / Meshy) | Does the AI 3D generation | Generation spends real credits. Alpha3D account at [alpha3d.io](https://alpha3d.io); see [Choosing your 3D provider](#choosing-your-3d-provider) for Tripo/Meshy. |
| **Blender 4.x or 5.x**, open, with a **Blender MCP bridge** add-on running | Lets the agent run `bpy` in your session | Any bridge exposing a `bpy` code-execution MCP tool works. The common one is [BlenderMCP](https://github.com/ahujasid/blender-mcp). |

> [!NOTE]
> This talks to a Blender instance on **your own computer**, so it will not work from a fully hosted sandbox with no local access. You run the agent and Blender side by side on the same machine.

## Installation

The skill has two parts, and setup depends on your client:

1. **Two MCP connectors.** Your **3D provider** (Alpha3D by default, at `https://api.alpha3d.io/mcp` with browser sign-in; or Tripo/Meshy, see [Choosing your 3D provider](#choosing-your-3d-provider)) and a **Blender bridge** (a local stdio server, e.g. `uvx blender-mcp`).
2. **The skill's instructions.** The `skills/alpha-scene-gen/` folder (`SKILL.md` plus `references/`). Claude Code loads these automatically as a skill or plugin. Cursor and Codex have no Agent Skills system, so the same two MCP servers get connected and the tool is pointed at these instructions through its own rules file or `AGENTS.md`. The `npx` installer below sets all of that up for you per client, so each one is a single command.

**The Blender side is identical for every client:** install a bridge add-on such as [BlenderMCP](https://github.com/ahujasid/blender-mcp) in Blender, and **start its server** (a button in the add-on's panel) each session. The per-client config below only tells your agent how to launch or reach that bridge, plus the remote Alpha3D server. You also need an [alpha3d.io](https://alpha3d.io) account with credits.

Claude Code

**Install the skill (easiest).** One command, no plugin, no clone. It copies the skill into your Claude Code skills folder:

```bash
npx github:ig-shadow-walker/3DGenSkill
```

By default it installs to `~/.claude/skills/alpha-scene-gen/` (available in every project). Add `--project` to install into the current repo's `.claude/skills/` instead, or `--dir ` to target any folder. Add `--provider tripo` or `--provider meshy` to generate through those instead of Alpha3D (see [Choosing your 3D provider](#choosing-your-3d-provider)). The installer is dependency-free and prints exactly what it copied. Claude Code discovers the skill from its `SKILL.md`; no restart needed.

Prefer not to use npx? Two other ways

- **Manual copy:** `git clone https://github.com/ig-shadow-walker/3DGenSkill.git`, then `cp -r 3DGenSkill/skills/alpha-scene-gen ~/.claude/skills/`.
- **Plugin marketplace**, if you'd rather manage it with `/plugin list`, `/plugin disable`, `/plugin uninstall` (requires Claude Code v2.1.143+):

  ```text
  /plugin marketplace add ig-shadow-walker/3DGenSkill
  /plugin install alpha-scene-gen@alpha3d
  ```

**Connect both MCP servers:**

```bash
claude mcp add --transport http alpha3d https://api.alpha3d.io/mcp
claude mcp add blender -- uvx blender-mcp
```

Alpha3D prompts for browser authorization on first use (this links your account so generation draws from your credits). In Claude Desktop or claude.ai, add the same Alpha3D URL from **Settings > Connectors**.

Cursor

One command in your project. It copies the skill, adds both MCP servers to `.cursor/mcp.json` (merging, never overwriting), and writes the rule that points Cursor at the skill:

```bash
npx github:ig-shadow-walker/3DGenSkill --cursor
```

Then, in Cursor, open **Settings > MCP**, make sure both servers are on, and click **Authenticate** on **alpha3d** to sign in. That browser step is the only thing a script can't do. If the login window doesn't open, toggle the server off and on.

Prefer to set it up by hand?

Add both servers to `.cursor/mcp.json` (project) or `~/.cursor/mcp.json` (global):

```json
{
  "mcpServers": {
    "alpha3d": { "url": "https://api.alpha3d.io/mcp" },
    "blender": { "command": "uvx", "args": ["blender-mcp"] }
  }
}
```

Then put the skill folder in your project and create `.cursor/rules/alpha-scene-gen.mdc` so Cursor always applies it:

```md
---
description: Alpha3D + Blender 3D scene generation workflow
alwaysApply: true
---

When the user asks to generate, build, or populate a Blender scene with 3D
assets, follow the workflow in `skills/alpha-scene-gen/SKILL.md` and its
`references/` files. Read them before acting.
```

OpenAI Codex CLI

One command in your project. It copies the skill and adds the reference to `AGENTS.md`:

```bash
npx github:ig-shadow-walker/3DGenSkill --codex
```

Then add the two MCP servers with Codex's own commands (use a current Codex; `codex mcp login` needs its late-2025 remote-MCP support, check with `codex --version`):

```bash
codex mcp add alpha3d --url https://api.alpha3d.io/mcp
codex mcp login alpha3d        # opens the browser sign-in
codex mcp add blender -- uvx blender-mcp
```

Prefer to set it up by hand?

Instead of the `codex mcp add` commands you can edit `~/.codex/config.toml`:

```toml
[mcp_servers.alpha3d]
url = "https://api.alpha3d.io/mcp"

[mcp_servers.blender]
command = "uvx"
args = ["blender-mcp"]
```

And add this to `AGENTS.md` (repo root, or `~/.codex/AGENTS.md` for all projects):

```md
## 3D scene generation in Blender

When the user asks to generate, build, or populate a Blender scene with 3D
assets, follow the workflow in `skills/alpha-scene-gen/SKILL.md` and its
`references/` files. Read them before acting.
```

### Verify

Open Blender on a scene and start the bridge server, then describe a small scene to your agent. The skill runs a free preflight check on both connectors before proposing anything, so if a connection is missing it tells you immediately instead of failing deep into a build.

## Choosing your 3D provider

The skill generates through one configured provider. **Alpha3D** is the default and the most fully supported (library reuse, live pricing, concept-image-to-3D). You can use **Tripo** or **Meshy** instead. All three return GLB, so the Blender import/place half is identical; only the generate step differs.

Pick it at install time with `--provider`:

```bash
npx github:ig-shadow-walker/3DGenSkill --provider meshy      # or tripo, or alpha3d
```

To change later, edit `provider` in `skills/alpha-scene-gen/provider.json` (wherever the skill was installed) and connect that provider's MCP. The skill reads this file at the start of every run.

Then connect that provider's MCP server. Alpha3D uses browser sign-in (no key); Tripo and Meshy each need an API key you paste into the command. **In every case you also connect the Blender bridge once** (`claude mcp add blender -- uvx blender-mcp`, or the Cursor/Codex equivalent from [Installation](#installation)). Pick your provider below.

Alpha3D (default, browser sign-in, no key)

```bash
# 1. install the skill for your client (default provider is already alpha3d)
npx github:ig-shadow-walker/3DGenSkill            # add --cursor or --codex for those clients

# 2. connect Alpha3D
claude mcp add --transport http alpha3d https://api.alpha3d.io/mcp   # Claude Code
codex mcp add alpha3d --url https://api.alpha3d.io/mcp && codex mcp login alpha3d   # Codex
```

Cursor: add `"alpha3d": { "url": "https://api.alpha3d.io/mcp" }` under `mcpServers` in `.cursor/mcp.json` (the `--cursor` installer does this for you), then click **Authenticate** in Settings > MCP. Sign-in links your [alpha3d.io](https://alpha3d.io) account so generation draws from your credits.

Tripo (API key: TRIPO_API_SECRET)

Get a `tsk_...` key from [platform.tripo3d.ai](https://platform.tripo3d.ai) (Settings > API keys), then:

```bash
# 1. install the skill and record tripo as the provider
npx github:ig-shadow-walker/3DGenSkill --provider tripo      # add --cursor or --codex for those clients

# 2. connect the Tripo MCP server (paste your key)
claude mcp add tripo -e TRIPO_API_SECRET=tsk_YOUR_KEY -- npx -y tripo-ai-mcp-server        # Claude Code
codex mcp add tripo --env TRIPO_API_SECRET=tsk_YOUR_KEY -- npx -y tripo-ai-mcp-server      # Codex
```

Cursor: add this under `mcpServers` in `.cursor/mcp.json`:

```json
"tripo": {
  "command": "npx",
  "args": ["-y", "tripo-ai-mcp-server"],
  "env": { "TRIPO_API_SECRET": "tsk_YOUR_KEY" }
}
```

Full tool contract and REST fallback: [`references/providers/tripo.md`](./skills/alpha-scene-gen/references/providers/tripo.md).

Meshy (API key: MESHY_API_KEY)

Get a `msy_...` key from [meshy.ai](https://meshy.ai) (

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [ig-shadow-walker](https://github.com/ig-shadow-walker)
- **Source:** [ig-shadow-walker/BlenderXAlpha-3DGenSkill](https://github.com/ig-shadow-walker/BlenderXAlpha-3DGenSkill)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-ig-shadow-walker-blenderxalpha-3dgenskill
- Seller: https://agentstack.voostack.com/s/ig-shadow-walker
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.
