The ultimate bot generator bot prompt. Use this prompt to create powerful ChatGPT bots for anything you can imagine.

Bot Generator Bot

Bot Generator Bot v2

Turn a bot idea into a runnable MetaHarness agent. Choose a template, define typed outputs, then export a standalone agent or run it through the CLI or MCP. The runtime uses the actual MetaHarness kernel, native RuVector memory and optional RuFlo routing. Model calls require explicit operator configuration; compilation stays offline.

The original 2023 project was a prompt collection. This preview adds working software while preserving that collection under prompts/ for historical reference. Those older prompts are not reviewed execution policies or qualified medical/legal systems.

Capability	What it does
Complete prompt catalog	All 39 original prompts migrated, plus support, research and code starters
Deterministic compiler	Same normalized specification produces identical manifest and SHA256
Typed output validation	Rejects missing/extra fields, invalid types and unsafe numbers
Operator tool policy	Requests must be in a fixed catalog and the operator allowlist; requests never grant authority
CLI and MCP	50 tools, 42 prompt templates and three resources
Runnable agents	Bounded model and tool loop, typed final output, standalone project export
RuVector memory	Private manifest-scoped lexical retrieval with native vector search
RuFlo routing	Optional pinned upstream keyword routing hook
MetaHarness	Actual kernel, host adapters, agent profiles, session replay and authenticated field memory adapter
Autogenous	Pinned upstream fitness gates with no automatic promotion
CI delivery	Tests, dependency audit, provenance checks and downloadable artifacts

Quick start

The qualified agent runtime requires Linux x64 and Node 24. Optional dependency trees are omitted by the repository install configuration. Clone this repository and run:

npm ci --ignore-scripts
node src/cli.mjs templates
node src/cli.mjs compile < fixtures/support-request.json > bot-manifest.json
node src/cli.mjs validate < fixtures/output-request.json
npm test
npm run benchmark

See Claude, Codex and ChatGPT setup for installable skills and MCP configuration, and prompt design for the evaluated contract.

The compiler input is { "spec": { "name", "purpose", "context", "examples", "output", "tools" } }; use the complete JSON example in fixtures/support-request.json. Output fields support string, number, integer and boolean. All fields are required and extra fields reject. The input cap is 32 KiB, strings 8 KiB, nesting 12 levels, and output schemas 16 fields.

Set BOT_ALLOWED_TOOLS=search locally to permit a specification to request the catalog's search tool. The agent runtime separately enforces the operator grant. Its supported tool is local memory search; other catalog tools are reserved and fail closed in this runtime. No tokens or provider credentials belong in specifications. verify checks manifest consistency, not authorship: an attacker can create a different consistent manifest.

Install the agent skill

The skill guides Claude Code and Codex through designing, validating and packaging an agent. Install it into the project where you want to use it:

npx -y [email protected] add ruvnet/Bot-Generator-Bot --skill bot-generator --agent claude-code codex --copy --yes
npx -y [email protected] list --json

For reproducible installation from a reviewed checkout, discover and install its local copy instead:

npx -y [email protected] add ./skills --list
npx -y [email protected] add ./skills --skill bot-generator --agent claude-code codex --copy --yes

The commands use project scope. Claude Code receives .claude/skills/bot-generator; Codex receives .agents/skills/bot-generator. Invoke /bot-generator in Claude Code or $bot-generator in Codex. Pinning the installer does not pin the GitHub repository revision; retain the reviewed checkout commit when reproducibility matters.

Try this request:

Use bot-generator to create a support agent from supplied product instructions. Discover the support template, add a missing evidence demonstration, compile and verify it, validate an output, and export a runnable agent. Show the manifest digest and checks. Do not call a paid model.

Installing a skill provides guidance. Install the repository dependencies and register its MCP server separately to make its tools callable. See the host guide for installation qualification and scope details.

Skills and tools for every original prompt

All 39 original prompts now have a curated typed agent template, an installable skill and a dedicated MCP builder. The complete catalog maps every original source to its skill and tool. Original text remains unchanged for provenance; modernized contracts define the supported behavior.

Discover the skills and install a selected one:

npx -y [email protected] add ruvnet/Bot-Generator-Bot --list
npx -y [email protected] add ruvnet/Bot-Generator-Bot --skill bgb-business-plan-bot --agent claude-code codex --copy --yes

Each build_ tool takes {} and returns a validated agent manifest without calling a model. For example, call build_business_plan_bot over MCP or run:

node src/cli.mjs build_business_plan_bot > business-agent.json

Use template with the catalog ID to customize its specification before compiling. Use agent_plan to package the returned manifest, or agent_run for a bounded model task with operator configuration. Each domain skill includes its own workflow, output schema, demonstration and original source digest. The catalog resource is ruv://bot-generator-bot/catalog.

The migrated skills create drafts, educational assistance and simulations within their stated scope. They do not claim to deploy APIs, book meetings, send messages, provide licensed professional services or run generated code. Those effects require separately available and authorized host integrations.

Connect the MCP server

After completing the quick start, register the reviewed checkout using an absolute path. The server uses local stdio and waits for protocol messages; it is not a web server or a published npm launcher.

Claude Code

claude mcp add --transport stdio --scope project bot-generator -- node /absolute/path/Bot-Generator-Bot/src/cli.mjs mcp
claude mcp get bot-generator

Codex

codex mcp add bot-generator -- node /absolute/path/Bot-Generator-Bot/src/cli.mjs mcp
codex mcp list

Alternatively, use the host's supported configuration scope and trust settings with:

[mcp_servers.bot-generator]
command = "node"
args = ["/absolute/path/Bot-Generator-Bot/src/cli.mjs", "mcp"]

These registration commands follow the official host documentation; automated qualification exercised the MCP protocol through the SDK, not the Claude or Codex interface. See Claude MCP setup and Codex MCP setup.

Tools, prompts and resources

The 39 dedicated catalog builders complement the 11 shared tools below. See the catalog for every builder name.

All tool arguments are JSON objects with exactly the documented fields. Send {} to tools with no arguments.

MCP tool	Arguments	Result
`status`	`{}`	Runtime policy and limits
`templates`	`{}`	Available starter names
`template`	`{"name":"support"}`	Editable specification; also accepts `research` or `code`
`compile`	`{"spec": ...}`	Deterministic versioned manifest
`verify`	`{"manifest": ...}`	Manifest consistency check
`validate`	`{"schema": ..., "value": ...}`	Strict typed output validation
`agent_plan`	`{"manifest": ...}`	Standalone project file map and hashes
`agent_run`	`{"manifest": ..., "input":"task"}`	Bounded model run requiring operator configuration
`agent_replay`	`{"manifest": ..., "id":"session UUID"}`	Local session integrity replay
`test`	`{}`	Bounded repository validation; operator opt-in required
`benchmark`	`{}`	Local deterministic compiler timing

Read ruv://bot-generator-bot/policy for execution boundaries and ruv://bot-generator-bot/prompt-guide for schemas, workflow and version guidance. MCP prompt discovery exposes all 39 catalog IDs plus support, research and code; each returns a {spec, manifest} starter artifact to inspect and compile.

A first connection check is templates → template → compile → verify. This flow needs no provider credentials. The host guide includes an example request and troubleshooting context.

Operator configuration

Set these in the server process environment, never in tool arguments or committed configuration:

Variable	Purpose
`BOT_ALLOW_VALIDATION=1`	Allow the MCP `test` operation
`BOT_AGENT_STORAGE`	Absolute private directory for agent state
`BOT_AGENT_ALLOW_LIVE=1`	Explicitly enable paid provider execution
`BOT_AGENT_API_KEY`	Dedicated provider credential supplied through a secret manager
`BOT_AGENT_MODEL`	Operator selected model
`BOT_ALLOWED_TOOLS=search`	Permit local memory search when the manifest also requests it
`BOT_AGENT_RUFLO=1`	Enable optional RuFlo keyword routing

Test subprocesses use one slot, a stripped environment, a 30 second deadline and a 64 KiB output bound. CLI test is an explicit local opt-in. MCP callers cannot choose executable commands, storage paths, destinations or endpoints. Installing the skill or connecting MCP does not enable paid execution.

ChatGPT

ChatGPT custom apps require a reachable remote MCP service with supported HTTP transport and authentication. This repository currently supplies local stdio MCP; it does not deploy a ChatGPT endpoint. A remote integration needs an authenticated gateway with user isolation and request limits. Installing through npx skills does not register a ChatGPT app. The separate federation endpoint https://x.ruv.io/mcp is not Bot Generator Bot's server. See ChatGPT integration requirements.

Prompt contracts and examples

New manifests use version 3. Existing version 2 manifests remain verifiable and runnable. Recompiling creates a new digest and private memory scope; it does not move old memory automatically.

Examples can be task hint strings or validated demonstrations:

{"input":"No installation guide was supplied.","output":{"answer":"Please supply the installation guide.","needsReview":true}}

Demonstration outputs must match the specification's output schema. Runtime adapters receive a shared response contract and examples wrapped consistently as {"output": ...}. The host validates every result and rejects incomplete provider responses. MCP prompt discovery returns an inspectable {spec, manifest} starter artifact, not privileged system instructions.

The three starter prompts now contain one validated demonstration each. Their serialized size grows from roughly 540 bytes to 1.2 to 1.4 KiB. This trades a small context increase for explicit examples and consistent contracts; model accuracy gains still need paired evaluation. See measured prompt sizes.

Run or export an agent

Compile a manifest using the quick start, then configure the model runtime locally:

export BOT_AGENT_STORAGE=/absolute/private/agent-state
export BOT_AGENT_ALLOW_LIVE=1
export BOT_AGENT_MODEL=your-approved-model
# Supply BOT_AGENT_API_KEY through your local secret manager.
node -e 'const fs=require("node:fs"); console.log(JSON.stringify({manifest:JSON.parse(fs.readFileSync("bot-manifest.json","utf8")),input:"Help draft a support reply"}))' | node src/cli.mjs agent-run

The provider endpoint is fixed to OpenAI. No live provider call is included in the test results. BOT_AGENT_RUFLO=1 enables the actual RuFlo keyword router; this is routing advice, not a distributed swarm deployment. For memory search, the manifest must request search and the operator must set BOT_ALLOWED_TOOLS=search.

agent-plan accepts { "manifest": ... } and returns a file map for a standalone project, with a CLI, stdio MCP, harness profile and pinned direct dependencies. Inspect and materialize those files in an operator-selected directory before installation. agent-replay accepts { "manifest": ..., "id": "session UUID" } and verifies the local session replay. Receipts are unsigned consistency evidence, not independent attestations.

Runs are limited to four turns, four tool calls, 30 seconds and 512 requested completion tokens per turn. Output and input are bounded to 8 KiB. One writer can use an agent scope at a time. Local memory is capped at 64 entries and logs at 128 sessions; archive sessions deliberately. Inspect a stale writer lock after a crash before removing it. Model output and retrieved content never authorize commands, filesystem access or federation publication.

See runtime architecture and optimization for the implementation and qualification boundary.

Harness and development

See the generated agent guide and governance gate. Install domain dependencies above before invoking domain commands through the generated CLI. Run generated tests, build and doctor using the guide. Sessions support replay/fork; field memory requires deployment-owned storage, verifier and identity key. No live memory service or autonomous deployment is provisioned.

Architecture decision, security review, validation evidence, selection provenance, and historical README explain the supported boundary and limitations.

RuV ecosystem

RuFlo supplies optional routing. RuVector supplies native memory search. MetaHarness supplies this repository's tested agent harness. Autogenous supplies the fitness gate. PromptLang is a related typed compiler, Dynamo MCP generates project scaffolds, and Federated MCP observes x.ruv.io. Related links are not claims of deployed integration.