Build with your agent. Ship on our runtime.

Start with one customer workflow. Describe it in Codex, Claude Code, or Cursor, prove it locally, then use Noodle Seed for the governed production boundary.

Install Noodle Seed in Codex

Read the quickstart

brightdesk · agent · 80×24Agentic coding workflow

Replay in

›claude plugin marketplace add NoodleSeed-com/plugins

One TypeScript definition. A complete production surface.

Define the API connection, customer identity, tool authorization, and React experience together. Noodle Seed validates and operates the result as one product surface.

Product definitionsrc/server.ts

import { connector, customerAuth, secret, server, tool, z } from '@noodleseed/one';

const productApi = connector('product_api').version('1.0.0').http({
  baseUrl: 'https://api.acme.com',
  allowedOrigins: ['https://api.acme.com'],
  auth: { kind: 'apiKey', header: 'X-Api-Key', secret: secret('PRODUCT_API_KEY') },
  operations: {
    list_accounts: {
      type: 'read', method: 'GET', path: '/v1/accounts',
      output: z.object({ accounts: z.array(z.object({ id: z.string(), name: z.string() })).max(50) }),
      response: { accounts: '${response.accounts}' },
    },
  },
});

export default server('account_workspace', {
  title: 'Account Workspace', version: '1.0.0', use: { product: productApi },
  auth: customerAuth.oidc({
    issuer: 'https://id.acme.com', audience: 'acme-agent-prod',
    claims: { id: 'sub', roles: 'permissions.roles', scopes: 'permissions.scopes' },
  }),
}, [
  tool('find_customer_accounts', {
    description: 'Find accounts the signed-in customer can access.',
    authorization: { requiredScopes: ['accounts:read'], allowedRoles: ['account_manager'] },
    input: z.object({}),
    output: z.object({ accounts: z.array(z.object({ id: z.string(), name: z.string() })).max(50) }),
    view: { component: 'account-list', entry: './views/account-list.tsx' },
    fulfil: ({ connectors }) => connectors.product.listAccounts(),
  }),
]);

noodle validate

Compile the product surface and catch contract problems.

noodle test

Prove the behavior locally before creating a hosted dependency.

noodle deploy

Publish the approved definition to the managed production boundary.

Author and prove locally. Sign in only when you are ready to deploy to the runtime.

A complete production path. Clear ownership at every boundary.

Your backend remains authoritative. Noodle Seed compiles, versions, and operates the governed production edge between it and every supported agent client.

Your product / API

TypeScript product definition

Compiler + local proof

Versioned control plane

Governed execution boundary

Agent clients

Your product

You own product data, workflows, permissions, and backend behavior.

Control plane

Organization, application, environment, deployment version, secrets, and rollout state stay connected.

Execution boundary

Caller identity, tenant routing, authorization, downstream credentials, execution, and evidence are applied around every action.

One definition. Multiple governed surfaces.

The compiler resolves your TypeScript into a versioned product definition. Noodle Seed projects the protocol, experience, connection, and operational surfaces without duplicating your product logic.

Protocol surface

Tools, resources, and prompts share the same typed product contract.

In-host experience

React Apps stay linked to the operations and permissions they represent.

Client connection

One managed endpoint connects through each supported host's verified configuration path.

Operational control

Metrics, events, releases, and deployment evidence stay attached to the same versioned product.

Deploy is the midpoint, not the finish line.

The same managed boundary that serves the capability also gives your team the evidence needed to operate it.

Metrics

See runtime health and usage without instrumenting a second control plane.

Events

Follow the action trail across deployed agent-facing capabilities.

Session replay

Reconstruct supported product sessions when an interaction needs investigation.

Filtered logs

Narrow operational evidence to the deployment, tool, or failure you are diagnosing.

Webhook alerts

Route important runtime signals into the systems your team already monitors.

Release history

Trace production behavior back to the capability version that introduced it.

Deployment inspection

Inspect the active deployment and its runtime state from one operational surface.

Know what the platform owns before you adopt it.

Evaluate the boundary category by category, then inspect the host and security evidence behind it.

Capability	DIY SDK	MCP host	Connector gateway	Noodle Seed
Product model	Imperative handlers	Bring a server	Connector configuration	One compiled product definition
Local proof	Build it	Varies	Varies	Validate and test locally
Generated product surfaces	Build each surface	Hosted endpoint	Connector tools	MCP + Apps + operations
Customer identity and tenancy	Build it	Varies	Agent-side	Managed boundary
Per-tool authorization	Build it	Varies	Agent-side	Scopes and roles
Operator model	Build it	Deployment settings	Agent-side	Org, app, environment, version
Operations and evidence	Build it	Hosting metrics	Connector logs	Managed boundary

One product definition. Evidence by host.

Protocol compatibility begins with the same product definition. Rich host presentation is verified separately, because every client evolves on its own schedule.

ChatGPTMCP-compatible

ClaudeVerified tools

CodexVerified tools

CopilotMCP-compatible

GeminiMCP-compatible

Generic MCPProtocol surface

Host validation continues

Security is enforced at the runtime boundary.

Resource-bound OAuth

Tokens are validated for the exact MCP resource and configured audience.

Tenant routing

Verified identity selects the customer boundary before connector execution.

Tool scopes and roles

Discovery and invocation enforce the same per-tool authorization rule.

Scoped credential exchange

Validated identity is exchanged for a narrow downstream credential.

Secret isolation

Connector secrets stay out of source, agent context, widgets, and runtime evidence.

SSRF protection

Connector egress is constrained to declared origins and routing policy.

Structural redaction

Operational evidence excludes request bodies, tokens, secrets, and nested values.

Security architecture Customer auth guide

Embed an assistant with ambient context.

Embed an assistant that understands the screen, acts for the signed-in user, and follows your existing permissions. Your product stays in control.

Create a short-lived session for the signed-in user.
Mount the assistant inside your product.
Fresh screen context travels with each turn.

Full guide

01 Create a sessionapp/api/assistant/session/route.ts

import { createAssistantSession } from "@noodleseed/assistant/server";

export async function POST(request: Request) {
  const user = await requireCurrentUser(request);
  const session = await createAssistantSession({
    serviceUrl: process.env.NOODLE_SERVICE_URL!,
    clientId: process.env.NOODLE_ASSISTANT_CLIENT_ID!,
    clientSecret: process.env.NOODLE_ASSISTANT_CLIENT_SECRET!,
    origin: process.env.PUBLIC_APP_ORIGIN!,
    user: { id: user.id, roles: user.roles, scopes: user.scopes },
  });
  return Response.json(session);
}

02 Mount the assistantcomponents/assistant.tsx

import { NoodleAssistant } from "@noodleseed/assistant/react";

<NoodleAssistant sessionEndpoint="/api/assistant/session" />

03 Provide ambient contextsrc/server.ts

tool("current_workspace", {
  contextProvider: true,
  input: z.object({}),
  output: z.object({
    workspaceId: z.string(),
    plan: z.string(),
    openProjects: z.number(),
  }),
  annotations: annotations.readOnly(),
  fulfil({ user }) {
    return loadWorkspaceFor(user.subject);
  },
});

// Every tool in this turn receives the same snapshot.
const workspace = context.ambient;

Go deeper when you need to.

Find the exact reference for what you are building next.

Quickstart

Examples

Package reference

Security and architecture

Production deployment

Embedded assistant guide

Bring your race engineer to production.

Join builders shipping agent-ready products, trade setup notes, and keep your runtime tuned for the next lap with Noodle Apex in your Codex garage.

Join the Discord

Download Noodle Apex