Build with coding agents
Build MCP servers with Codex and Claude Code using Noodle Seed's project instructions, validation loop, and ready-to-use prompts.
Noodle Seed is designed for agentic engineering. Because a whole MCP server is one declarative
server.ts, a coding agent like Codex or Claude Code can author it end to end, check its own
work with noodle validate, and iterate, all without you writing boilerplate.
Why agents are first-class here
One TypeScript file, typed schemas, and structured compile errors mean an agent has a tight, machine-checkable loop: bootstrap a tested baseline, adapt the business seams, test, and repair specific failures.
Install the Noodle Seed plugin
Give your agent the Noodle Seed knowledge globally, before any project exists. The plugin ships the
noodle-seed skill, so a bare "build me an MCP app" prompt already reaches for the noodle CLI,
scaffolds with noodle init, and runs the validate loop.
The developer plugin guide owns the complete Codex, Claude Code, and Cursor install path, managed CLI boundary, build-readiness UI, Noodle Cloud auth, and lifecycle behavior.
/plugin marketplace add NoodleSeed-com/plugins
/plugin install noodle-seed@noodleseedCodex reads the same marketplace:
codex plugin marketplace add NoodleSeed-com/plugins
codex plugin add noodle-seed@noodleseedCursor users can install from the Cursor Marketplace when listed or through an administrator-configured team marketplace before listing. Sign in through OAuth only for hosted operations, and never paste a token or secret into chat.
Once a project is scaffolded, noodle init installs a fuller project-local skill (see below) and the
plugin defers to it.
The agentic loop
The agent starts from maintained profiles and recipes, then adapts server.ts and the generated host-side
integration seams. It runs the project's agent:check script after each meaningful change and repairs the
specific failures. Local synthetic proof is not customer-auth, real-write, or deployed proof; test each real
boundary before claiming it works. Hosted deployment remains a separately authorized action.
Project agent files
noodle init writes project-local Codex and Claude Code files so your agent starts with the right
context: the authoring SDK surface, the rules (TypeScript only, no hand-written manifests, secrets via
secret("NAME")), and the validate-repair loop.
npx --yes @noodleseed/one@latest init my-server --json
cd my-server
npm exec -- noodle agents setup --write # refresh later; preview without --write
npm exec -- noodle agents doctorThese files are project-local and non-secret. They never include tokens, credentials, or
~/.noodle/config.json contents.
Inspect setup.ready, completed, failed, proof, and restartRequired before proceeding. Init installs
pinned local tooling and verifies context, compilation, behavior and types; --no-install is files-only.
Resume a failure with its reported command, preserving edits and the existing package manager. JSON/plugin
setup never launches another agent. Read the new project skill explicitly in the current session, or start
a fresh session yourself; newly written instructions are not automatically loaded into an existing agent.
The Noodle workflow skills teach the agent how to build and operate projects. A guided app can also generate its own separately owned skill that teaches the agent how to use that product. See Product agent guides for the distinction, decision criteria, and safe regeneration flow.
Connect the agent to your server
Start the dev server, then in another terminal wire your agent (or any MCP client) to the local endpoint:
noodle devnoodle connect claude-codenoodle connect also supports codex, cursor, vscode, gemini, and inspector.
Now the agent can call your tools directly to test them as it builds.
Feed the docs to your agent
Export these docs in an LLM-friendly format to drop into an agent's context:
noodle docs export --format llms --output noodle-docs.txtCopy a prompt
Paste one of these into Codex or Claude Code to get started. Replace the bracketed part with your idea.
Use Noodle Seed in this project.
For a new project, run `npx --yes @noodleseed/one@latest init my-app --json`. Inspect setup.ready and any failed stage, then read the generated project-local skill and its requested reference. Resume failures with the reported command, never --force. For an existing project, reconcile with `noodle setup --write --json`; preserve unrelated files and the existing package manager.
Build a Noodle Seed server for: [describe the ChatGPT app, Claude connector, MCP app, Codex plugin, or Claude Code plugin I want].
Rules:
- Work inside the initialized project directory. Run every noodle command through its package-manager-local CLI (for npm: `npm exec -- noodle`); do not assume a global installation.
- Author TypeScript with the `@noodleseed/one` SDK.
- Do not hand-write manifest JSON or YAML.
- Do not hard-code secrets. Use `secret("NAME")` and tell me which `noodle secrets set` commands I need.
- Keep the implementation focused in `server.ts` unless the project already has a Noodle Seed layout.
- After every meaningful change, run `noodle validate` and fix the reported errors until validation passes.
- Then run `noodle dev` for local testing.
- When I approve, run `noodle deploy` and show me the MCP endpoint and the `noodle connect` command for Claude, ChatGPT, Codex, or Claude Code.Add a new tool to my Noodle Seed `server.ts`.
- Use the `@noodleseed/one` SDK; the tool needs a Zod `input`/`output` schema and a `fulfil` function.
- If it needs an external API, add or reuse a `connector(...).http({...})` on the server `use` map.
- Run `noodle validate` and resolve every reported error before you finish.
Tool: [describe the action and its inputs/outputs].Run `noodle validate` on my Noodle Seed project and fix every error it reports.
Work through them one at a time, re-running `noodle validate` after each fix, until it passes.
Do not change unrelated code, and keep everything in `server.ts`.Integrate the Noodle Seed embedded assistant into this existing SaaS application.
Use only the public Noodle CLI, generated project instructions, and `@noodleseed/assistant`. Inspect the
repository's framework, authentication, package manager, local HTTPS support, and server-only environment
conventions before editing. Reuse the existing authenticated user through a backend session-exchange route,
mount the browser SDK only in the authenticated application shell, and keep all model and client credentials
out of browser code. Configure exact HTTPS local and production origins. Run `noodle commands --json` before
proposing flags, then validate and test. Do not deploy or create credentials until I explicitly approve.Next steps
Quickstart
The manual version of the loop above.
Tools, resources & prompts
The SDK surface an agent authors against.
Designing tools for agents
The doctrine your coding agent already follows: task-shaped tools, titles and hints, bounded outputs, deliberate context.
Product agent guides
Teach an agent how to use one multi-capability product, then preview, install, and regenerate its local product skill safely.
Embed an assistant
The complete HTTPS, deployment, credential, backend, and browser workflow.
Connectors
How agents wire servers to real APIs.
Quickstart
Install the Noodle Seed plugin for Claude Code or Codex, validate and run an MCP server locally without an account, then sign in to deploy a governed URL.
Core concepts
Learn how Noodle Seed compiles one server.ts into a governed MCP server with shared runtime, tenancy, connectors, credentials, and policy.