Models you canrouteunder your own brand.
Write namespaced models in TypeScript, attach tools, deploy them, and issue scoped keys. Neutrome runs the workspace infrastructure and usage billing.
No payment required · Cloudflare deploys · usage billing
Request path
A client key reaches the workspace runtime, the model code runs, and the caller receives the response.
Sample request
- 1
Authenticate the client key
The runtime verifies the workspace API key and checks whether it may reach the requested model or namespace.
- 2
Resolve the model route
The requested model id maps to a deployed executor, here
support/refund-router. - 3
Run executor code and tools
The model source runs, attached tools may be called, and the executor shapes the upstream request.
- 4
Relay the final response
The response streams back while usage billing is queued.
Execution log
Example response
The missing layer between models and agents
Raw models leave little room for product logic. Full agents bring more machinery than many customer-facing models need. Neutrome runs code for a namespace/model between the client request and the upstream model.
| Criterion | Raw LLM | Programmable model | Agent |
|---|---|---|---|
| What it is | A single inference target | A managed runtime that exposes model logic as a normal API | An application loop coordinating many steps and systems |
| Primary role | Generate the next response | Resolve a model route, run executor code, return the final response | Pursue a broader task over time |
| Execution model | Single provider request | Model code runs between the client request and the upstream call | Multi-step or long-running orchestration |
| Tools | Returned for the caller to execute | Attached tools are wired at deploy time and invoked by the runtime | Explicitly orchestrated as part of the larger workflow |
| Model composition | One model per request | Route to one or more upstream models from executor code | Dynamically chooses models and tools while pursuing a goal |
| I/O control | Prompt and parameter level only | Inspect, rewrite, validate or replace requests and responses | Maintains and mutates full workflow state |
| State | Stateless | Mostly stateless execution plus workspace config | Often stateful with memory or task history |
| Client experience | Standard LLM API | Standard API surface, with the routing logic behind the runtime | Agent-specific interface or application surface |
| Infrastructure | Inference server | Workspace deploys, API keys, billing hooks and provider routing | Separate workers, jobs and application state |
| Streaming | Native token streaming | Preserved whenever the executor yields upstream chunks | Often paused by planning or coordination steps |
| Best for | Direct model access | Namespaced models with custom logic, tools and managed access | Complex task automation across multiple systems |
Products running on Neutrome
These teams use namespaced models, attached tools, and scoped client access in their products.
Your model is code
The dashboard includes four @neutrome/lil-engine templates: a direct passthrough, a two-stage router, a response filter, and a fallback chain.
Use a template as a starting point, then deploy the version you need to a workspace.
Compose models
Use a fast model for one step and a stronger model for another when the task calls for it.
Control requests
Rewrite prompts, apply policy, or choose the route before a request reaches the provider.
Attach tools
Make internal lookups and helper functions available to a model.
Transform replies
Inspect or change a response before it returns to the client.
Starter templates
import type { Executor } from "@neutrome/lilsdk";
const model = "openai/gpt-oss-20b";
const executor: Executor = {
execute(request, ctx) {
return ctx.invoke(model, request);
},
stream(request, ctx) {
return ctx.invokeStream(model, request);
},
};
export default executor;
The expected runtime behavior appears here.
This preview illustrates the selected template. It does not run TypeScript.
From model code to a deployed workspace
Create a workspace, deploy the runtime, and give customers or teammates access.
Run models as
Your own AI provider.
Keep prompting logic, routing rules, and internal context in the same workspace as the models that use them. Group models under namespaces, deploy them, and choose which keys can reach them.
Workspaces currently include scoped access, deployment routes, and billing.
Core developer suite: TypeScript models · starter templates · tool attachments · billing dashboard.
Build and deploy from one workspace
The platform keeps model source, deployments, access, and billing together.
- TypeScript and JavaScript model source
- Namespaced model ids
- Attached runtime tools
- Draft and deployed versions
- Scoped API keys by namespace or model
- Inline dashboard test client
- Workspace usage billing
- Stripe balance top-ups
support/refund-router Source: TypeScript Tools: order-lookup, refund-policy Status: deployed
Give your team a scoped key and the deployed workspace URL. The workspace holds the model catalog, access rules, and usage billing.
Charge for the model work you run
Put internal workflows, routing rules, or domain expertise behind a workspace. Neutrome issues client keys and records usage.
Billing is workspace-based today. The same balance and event system can support more packaging options later.
Frequently asked questions
Create a programmable model
Create a workspace, add a namespace, write a model, and deploy it from the dashboard.