Deploy and Host Manifest on Railway

Manifest is an open-source AI provider gateway for agents and apps — connect your API keys, provider subscriptions, local models, and any custom OpenAI-compatible endpoint behind one unified endpoint and dashboard. Your agents talk to a single OpenAI-compatible URL, and Manifest routes each request to the right provider, so you're never locked into one platform. This template deploys Manifest with PostgreSQL on Railway, ready to connect providers in minutes.

What This Template Deploys

Both services run on Railway's private network. Manifest exposes one OpenAI-compatible endpoint your agents point at; the dashboard manages every connected provider behind it.

About Hosting

Manifest solves a specific problem: agents and apps that get locked into a single LLM provider, with keys and configuration scattered across codebases.

One endpoint in front of every provider. Manifest sits between your agents and your models as an OpenAI-compatible proxy. Point any OpenAI SDK client at Manifest's URL, and it routes to whatever you've connected behind it — no per-provider integration, no lock-in. Switching or adding providers happens in the dashboard, not in your agent's code.

It connects more than just API keys. This is where Manifest stands out from a plain gateway. It supports four kinds of provider at once: bring-your-own API keys for cloud providers (OpenAI, Anthropic, and dozens more), provider subscriptions (reuse subscription flows instead of only pay-per-token keys), local models (Ollama, LM Studio, llama.cpp, or any local server), and custom OpenAI/Anthropic-compatible endpoints. All of them route through the same endpoint, so an agent can mix cloud, subscription, and local models transparently.

Smart routing and fallback come built in. Manifest scores each request and can route to the most appropriate model — including sending simpler requests to cheaper models to cut cost — with the decision made locally in milliseconds, adding no meaningful latency. If a provider fails, it automatically falls back to another, and it tracks every request, token, and dollar per agent and provider in the dashboard.

Two services, minimal footprint. Manifest runs as a container with PostgreSQL for its state. The first account you create becomes the admin; from there you connect providers and generate a per-agent base URL and key. Keep the dashboard access-controlled, since it holds all your provider credentials.

Typical cost: ~$5–10/month on Railway for Manifest and Postgres, plus whatever you pay your providers directly (Manifest doesn't mark up usage).

How It Compares

A single-provider SDK ties your agent to one vendor. OpenRouter is managed but adds a fee and routes through its cloud. LiteLLM is a capable self-hosted proxy but leans key-and-local. Manifest's edge is unifying API keys, subscriptions, local models, and custom endpoints behind one gateway with a dashboard — the broadest provider mix, self-hosted, with no lock-in.

Deploy in Under 5 Minutes

1. Click Deploy on Railway — Manifest and PostgreSQL build automatically (~3 minutes)
2. Confirm the database reference variables are wired and the app is healthy
3. Open the dashboard at your Railway domain and create the first admin account
4. Connect providers — add API keys, subscriptions, or local/custom endpoints under Connect Providers
5. Click Connect Agent to generate a base URL and key, then point your OpenAI client at it

Your agents now reach every connected provider through one endpoint — swap or add providers without touching code.

Common Use Cases

• No provider lock-in — build agents against one endpoint and switch or mix providers freely from the dashboard
• Unify keys, subscriptions, and local models — route cloud API keys, subscription plans, and Ollama/local models through a single URL
• Centralized credential management — keep every provider key in one gateway instead of scattered across codebases
• Reliable agents — automatic fallback to another provider when one is down, so agents don't break on an outage
• Usage visibility — track spend, tokens, and requests per agent and provider in one dashboard

Configuration

The dashboard holds all your provider credentials. Every connected API key and subscription lives behind it, so keep the instance access-controlled and use a strong admin password. Railway's automatic HTTPS encrypts traffic in transit.

Provider costs are billed by the providers, not Manifest. You bring your own keys and subscriptions and pay each provider directly — Manifest routes and tracks usage without marking it up.

Dependencies for Manifest Hosting

• Railway account — ~$5–10/month for Manifest and Postgres
• PostgreSQL (included in the template)
• API keys, subscriptions, or local model endpoints for the providers you want to route to
• Optional: an Ollama or local server if routing to local models

Deployment Dependencies

• Manifest GitHub Repository
• Manifest Website
• Manifest Docker & Self-Hosting Guide
• Railway Private Networking

Implementation Details

The template runs the official Manifest Docker image alongside a Railway PostgreSQL service, with the database connection supplied through a reference variable. Manifest exposes an OpenAI-compatible gateway and a management dashboard on port 2099; the first account created becomes the admin, after which providers are connected through the UI and each agent receives its own generated base URL and API key.

Behind the single endpoint, Manifest routes to any connected provider — cloud API keys, subscription flows, local model servers (Ollama, LM Studio, llama.cpp), and custom OpenAI- or Anthropic-compatible endpoints — with provider catalogs discovered dynamically as credentials are added. Routing can score requests to pick an appropriate model and falls back to an alternate provider on failure, while usage is tracked per agent, key, and provider. The routing decision is computed locally without calling another model, so it adds negligible latency.

Because the dashboard stores all provider credentials, access control and a stable signing secret are the key operational concerns; the deployment itself is lightweight, with Postgres holding configuration and usage state.

Frequently Asked Questions

What does Manifest actually do? It's a gateway that sits between your agents and LLM providers. Your agent points at one OpenAI-compatible endpoint, and Manifest routes each request to whichever provider you've connected — keys, subscriptions, local, or custom — so you're not locked into one platform.

How is it different from just using a provider's SDK? An SDK ties you to one vendor. Manifest lets you connect many providers behind one endpoint and switch or mix them from a dashboard without changing agent code — plus fallback, routing, and usage tracking.

What kinds of providers can I connect? Cloud API keys (OpenAI, Anthropic, and many more), provider subscription flows, local models (Ollama, LM Studio, llama.cpp), and any custom OpenAI/Anthropic-compatible endpoint — all through the same URL.

How do I connect my agent? In the dashboard, click Connect Agent, name it, and pick the SDK type. Manifest generates a base URL and key — point your OpenAI client at them and it works with no logic changes.

Does Manifest mark up my usage? No. You bring your own keys and subscriptions and pay providers directly. Manifest routes and tracks usage; the infrastructure cost is just Railway.

Is my data and are my keys private? Yes — everything runs on your Railway deployment. Keep the dashboard access-controlled since it holds provider credentials, and rely on Railway's HTTPS.

Why Deploy Manifest on Railway?

Railway is a singular platform to deploy your infrastructure stack. Railway will host your infrastructure so you don't have to deal with configuration, while allowing you to vertically and horizontally scale it.

By deploying Manifest on Railway you get a self-hosted AI provider gateway in one click — Manifest and PostgreSQL pre-wired, one OpenAI-compatible endpoint for keys, subscriptions, local, and custom providers, with routing, fallback, and usage tracking built in. Free your agents from provider lock-in, on infrastructure you own.