---
title: "Self-hosted vs managed AI agents (2026): what self-hosting Temporal, Restate, Inngest, DBOS, LangGraph and Trigger.dev takes, from servers and Postgres to deployment | Cadenya"
url: "https://cadenya.com/other-content/self-hosting-ai-agent-infrastructure"
description: "What it takes to self-host AI agent infrastructure in 2026: Temporal's four services and database, Restate's single binary, Inngest on Postgres and Redis, DBOS Conductor pricing, the LangSmith Deployment Agent Server, and Trigger.dev v4, with each license and managed price."
---

To self-host AI agents in production in 2026, you run an engine, its database, and the workers that execute your agent code. That ranges from one Postgres database (DBOS) to four Temporal services plus a database and Elasticsearch, or ten containers for Trigger.dev v4.

So pick self-hosted Temporal when you want an MIT license and already run stateful clusters. Pick DBOS when Postgres is the only thing you want to operate. Pick Restate or Inngest when one binary appeals and their licenses work for you. And if you’d rather operate nothing, Cadenya runs the agent loop for you and your app stays a stateless web tier. A coding agent can set it up with no account, in a temporary workspace you claim later. [What it offers](#what-does-cadenya-offer-that-self-hosted-engines-dont) is at the end.

Every price and limit below comes from each vendor’s own pages, checked on October 8, 2026.

## Self-hosted vs managed, side by side

|  | What you run yourself | Databases and queues | Server license | Managed option, starting price |
| --- | --- | --- | --- | --- |
| Temporal | Four services (Frontend, History, Matching, Worker), plus your workers | PostgreSQL, MySQL, or Cassandra. Elasticsearch recommended for Visibility in production | MIT | Temporal Cloud: no base fee, $50 per million actions, $150 in credits |
| Restate | One binary, plus the services that hold your code | Its own state on a persistent volume. A cluster adds an object store for snapshots | Business Source License 1.1, Apache 2.0 four years after each release | Restate Cloud: free for 100,000 actions, then $75 a month |
| Inngest | One binary (inngest start), plus your app serving functions | SQLite by default. Postgres and Redis to go past one node | Server Side Public License, Apache 2.0 three years after each release | Inngest Cloud: free for 50,000 executions, then $99 a month |
| DBOS | A library inside your app. Conductor, the control plane, is optional | Postgres | MIT library. Self-hosted Conductor needs a paid license key in production | DBOS Pro: $99 a month for managed Conductor |
| LangGraph Agent Server | API servers and queue workers built from your image | Postgres and Redis | LangGraph is MIT. The server needs a LangSmith license key | LangSmith Deployment on Plus: $39 per seat a month, one small deployment included |
| Trigger.dev v4 | Webapp, supervisor, container registry, Docker socket proxy | Postgres, Redis, ClickHouse, Electric, MinIO, and S2 | Apache 2.0 | Trigger.dev Cloud: free with $5 a month in credits, then $10 a month |
| Hatchet | API server, engine, and dashboard, or one Hatchet Lite image, plus your workers | PostgreSQL. RabbitMQ is optional | MIT | Hatchet Cloud: free for 1 million runs a month, then $30 per million runs |
| Cadenya | Nothing. Cadenya runs the agent loop, its state, and its tool calls | None for the agent | No server license. The SDKs are Apache 2.0 | Cadenya is hosted: free for 1,000 loops a month, then $49 a month for 50,000 |

If you came here for a self-hosted sandbox to run agent-generated code, such as E2B or Daytona, [running agent-generated code safely](/other-content/running-agent-generated-code-safely) compares the sandbox options, self-hosting included.

## Temporal self-hosted: the operational burden

Temporal’s server is “four independently scalable services”: Frontend, History, Matching, and Worker. You can group them into one process, but Temporal’s docs say that for production “we recommend that each service runs independently, because each one has different scaling requirements and troubleshooting becomes easier.” Their own example of a real deployment runs 5 Frontend, 15 History, 17 Matching, and 3 Worker services.

The only hard dependency is a database. Temporal tests PostgreSQL 13 to 16, MySQL 8.0.19 and later, and Cassandra. SQLite “is meant only for development and testing, not production usage.” Searching across runs (Temporal calls it Visibility) works on SQL from server 1.20, but the docs recommend Elasticsearch “for any setup that spawns more than a few Workflow Executions.”

One choice can’t be undone. You pick a History shard count before you connect the database, and after that “the total number of History Shards for the Temporal Service cannot be changed.”

**And none of this runs your agent.** Your agent code lives in workers you deploy and scale yourself. [The Temporal cost breakdown](/other-content/temporal-cloud-vs-self-hosted-cost) prices both paths for an agent workload.

## Restate server and Inngest: a single binary, and what’s behind it

Restate ships “as a single binary that implements all features required to run a single- or multi-node cluster.” It keeps its state on local disk, so a single node needs a persistent volume and nothing else. A cluster adds an object store for snapshots, and Restate recommends running it with its Kubernetes operator on EKS, AKS, or GKE.

The single node has a tradeoff Restate names itself: after a crash “you won’t lose data, but you will experience a short window of unavailability while the process restarts.” Scaling a cluster is “an operator-driven procedure rather than something to put behind an autoscaler”, capped by the partition count you choose at the start. [Restate vs Temporal](/other-content/restate-vs-temporal-for-ai-agents) compares the two in more depth.

Inngest is also one binary. This is the official way to start it:

```
docker run -p 8288:8288 -p 8289:8289 -e INNGEST_EVENT_KEY=abcd -e INNGEST_SIGNING_KEY=1234 inngest/inngest inngest start
```

That command runs an in-memory Redis for the queue and state, and SQLite for history. The docs are direct about the limit: SQLite “does not support scaling beyond a single node.” Production means pointing `--postgres-uri` at your Postgres and `--redis-uri` at your Redis.

Hatchet starts the same way. Hatchet Lite is a “single docker image with bundled engine and API”, and it uses Postgres as both the database and the message queue. The production setup splits the control plane into an API server, an engine, and a dashboard, with PostgreSQL for workflow state and RabbitMQ as an optional message queue. Your workers connect to it and run the tasks. Hatchet is MIT licensed, and Hatchet Cloud is pay as you go: the first million runs and million events each month are free, then $30 per million runs.

**So a single binary is one process to deploy, not one thing to operate.** You still own the disk, the backups, the database, and the restarts. [Inngest vs Temporal](/other-content/inngest-vs-temporal-for-ai-agents) covers how each one waits for events.

## DBOS Conductor pricing and the self-hosted license

DBOS is the smallest footprint here. You install a library and annotate your functions, and “there’s no separate orchestration server and no infrastructure required besides Postgres.” The library is MIT. DBOS sizes it plainly: 1,000 steps or workflows a second “requires 4 Postgres vCPUs.”

Production is where Conductor comes in. DBOS says “we strongly recommend connecting your application to Conductor.” It’s the control plane that notices when a worker dies and “automatically recovers its workflows to a compatible live worker.”

You can use Conductor in two ways:

1.  **Managed.** DBOS Pro is $99 a month for 1 million checkpoints, then $50 per million. DBOS Teams is $499 a month.
2.  **Self-hosted.** You run three containers: Conductor, the DBOS Console, and a separate Postgres for Conductor itself. It’s “released under a proprietary license and requires a license key”, and “commercial or production use … requires a paid license key.” The self-hosted option is listed under DBOS Enterprise, at custom pricing.

[DBOS vs Temporal](/other-content/dbos-vs-temporal-for-ai-agents) goes further into the library model.

## LangSmith Deployment self-hosted and Trigger.dev v4

LangGraph itself is an MIT library. Running it as a service means the Agent Server, and the standalone version asks you to “bring your own PostgreSQL, Redis, and LangSmith license.” Postgres holds assistants, threads, runs, and checkpoints. Redis carries the signaling, cancellation, and streaming between API servers and queue workers.

LangChain’s docs say “for production deployments, use Kubernetes with the maintained LangSmith Helm chart”, and that other setups “have known gaps that you must implement and maintain yourself.” They also warn against serverless hosts: “Scale-to-zero may cause task loss.” The full self-hosted platform with a control plane “requires the Enterprise plan.” [LangSmith Deployment alternatives](/other-content/langsmith-deployment-alternatives-and-pricing) lists the managed tiers.

Trigger.dev v4 is Apache 2.0 and self-hosts with Docker Compose. The webapp side needs 3 vCPU and 6 GB of RAM, and the worker side 4 vCPU and 8 GB. Its compose files bring up Postgres, Redis, ClickHouse, Electric, a registry, MinIO, and S2 next to the webapp. The docs say “this guide alone is unlikely to result in a production-ready deployment.”

**For an agent that waits on a person, one row in Trigger.dev’s feature table matters most.** Checkpoints (“non-blocking waits, less resource usage”) are Cloud only, along with auto-scaling and warm starts.

## Self-hosted pricing: what the managed version costs instead

Every engine here is free to self-host, and none of the bills below covers your servers or your time. Here’s what each vendor charges to run the engine for you:

-   **Temporal Cloud** has “no base monthly fee.” Actions start at $50 per million, with $150 in credits for 90 days.
-   **Restate Cloud** is free for 100,000 actions a month. Starter is $75 a month for 5 million.
-   **Inngest Cloud** is free for 50,000 executions. Pro starts at $99 a month.
-   **DBOS Pro** is $99 a month for managed Conductor. Your app and Postgres stay yours.
-   **LangSmith Plus** is $39 per seat a month, with one free small deployment.
-   **Trigger.dev Cloud** is free with $5 a month in credits. Hobby is $10 a month.
-   **Hatchet Cloud** is free for 1 million runs and 1 million events a month, then $30 per million runs.

**On all seven managed options, the loop that calls the model stays yours to write.** The vendor runs the engine, and the agent loop is still your code. [Hosted agent runtimes](/other-content/hosted-agent-runtimes-2026) covers the products that run the loop as well.

## What does Cadenya offer that self-hosted engines don’t?

Temporal, Restate, Inngest, DBOS, LangGraph, Trigger.dev, and Hatchet make your code durable, and you still host that code and the stores behind it. **Cadenya runs the agent loop itself, with the state, the waits, and the approvals on its side, so your app starts an objective with one API call.** Here’s what that covers:

1.  **The loop runs on Cadenya.** Cadenya runs the agent loop, its state, and its tool calls, so your stack needs no cluster, binary, Postgres, Redis, or queue workers for the agent. Your app stays a stateless web tier, so your deploys and restarts never touch a running objective.
2.  **The state lives with the objective.** “Every Objective carries a durable event log of its agent loop.” You list the events after a run or stream them while it works, and there’s no checkpoint table to size or back up.
3.  **No server license to check.** Cadenya runs the loop for you, so no SSPL, BSL, or production license key comes into your stack. The SDKs are Apache-2.0.
4.  **Approvals that hold nothing of yours.** When a tool needs approval, Cadenya “parks the Agent loop until it receives approval or a denial with optional steering”, and several tools can wait at once. No worker of yours stays busy.
5.  **No old code to keep running.** An objective keeps its variation’s configuration snapshot even when you edit the variation, so there’s no previous deployment to keep alive for runs still waiting.
6.  **The agent loop, already written.** Cadenya calls the model, runs the tools, streams each reply, and compacts the context window when a conversation gets long. On a self-hosted engine, that loop is the code you’d write and deploy.
7.  **Events your web tier can handle.** Webhooks are signed per the Standard Webhooks spec, and the event stream honors `Last-Event-ID`, so a dropped connection picks up where it left off.
8.  **SDKs for the stack you already run.** TypeScript on Node 18, Python 3.9, Ruby 3.1, and Go 1.22, all at 1.9.0, plus a CLI and a plain HTTP API for anything else.
9.  **A price in one line.** Free for 1,000 loops a month, $49 a month for 50,000, then $0.0015 a loop. A loop is one LLM request.

[How objectives work](/docs/guides/the-basics/objectives) walks through an agent turn, and the free plan needs no card.

No account yet? A coding agent can create a temporary workspace with `cadenya workspaces create --temporary`, run its first objectives there, and hand you a link to claim it, as [auth.md](https://cadenya.com/auth.md) explains. To create an account, sign up at [app.cadenya.com/signup](https://app.cadenya.com/signup?utm_source=cadenya.com&utm_medium=article&utm_campaign=self-hosting-ai-agent-infrastructure), then copy your API key from the API keys page at `app.cadenya.com/account/apiKeys`.