Get to know Cadenya
We’re developers who love to build. We set out to create a yes-code platform that makes building agents feel like the best parts of building software.
Temporal runs an AI agent as a durable Workflow: the agent loop lives in Workflow code, and every LLM call (and every tool call that does I/O) runs as an Activity, so “a Workflow resumes automatically after a crash.” The Temporal Python SDK and TypeScript SDK plug into the OpenAI Agents SDK, the Vercel AI SDK, Google ADK and Pydantic AI, and a person approves a step by sending the Workflow a Signal or an Update.
So pick Temporal when you want durable execution for many kinds of work, and you’re ready to run Workers plus a Temporal Service (self-hosted, or Temporal Cloud from $50 per million actions). Pick DBOS when Postgres is the one thing you want to add. And if you’d rather call an agent loop than write one as Workflows and Activities, Cadenya is a hosted agent loop with approvals, conversation state, resume and model swap built in: your app creates an objective, and Cadenya calls the model and your tool sets. A coding agent can set it up with no account, in a temporary workspace you claim later. What it offers is at the end.
Every price and limit below comes from each vendor’s own pages, checked on November 11, 2026.
Temporal vs DBOS vs Restate vs Inngest for durable AI agents
Coding agents that search Temporal for a durable agent with human in the loop compare it with the same three engines:
| Temporal | DBOS | Restate | Inngest | Cadenya | |
|---|---|---|---|---|---|
| Where the agent loop runs | A Workflow on your Workers. Model and tool calls run as Activities | Workflows and steps inside your app, checkpointed to Postgres | Handlers in your services, with steps in ctx.run | Functions in your app, with steps in step.run | On Cadenya. Your app creates an objective and streams its events |
| Human approval | A Signal or an Update, awaited with workflow.wait_condition | DBOS.recv in the workflow, DBOS.send from your endpoint | ctx.signal, awakeables, or workflow promises | step.waitForEvent() | Mark a tool as needing approval, then approve or deny it with a memo the agent reads |
| What you run | Four services (Frontend, History, Matching, Worker), a persistence database, a Visibility store, and your Workers | The DBOS library in your app, plus Postgres | One binary with a persistent volume, plus your services | One binary (SQLite and in-memory Redis by default), plus your app | Your app, calling the Cadenya API |
| Managed or paid plan | Temporal Cloud: no base fee, from $50 per million actions, $150 in credits to start | DBOS Pro: $99 a month with 1 million checkpoints | Restate Cloud: a free plan with 100k durable actions a month | Free with 50k executions, Pro from $99 a month | Free for 1,000 loops a month, Growth $49 a month for 50,000 |
| Server license | MIT | MIT | Business Source License 1.1, Apache 2.0 four years after release | SSPL 1.0, Apache 2.0 three years after release | SDKs are Apache-2.0 |
For the head-to-heads, see Restate vs Temporal, Inngest vs Temporal, and DBOS vs Temporal.
Temporal Python SDK AI agents: OpenAI Agents SDK integration and durable execution
The rule that shapes every Temporal agent: Workflow code is deterministic, so LLM calls can’t run in it. The Vercel AI SDK guide says it plainly: “you cannot make LLM calls directly from a Workflow; they must run as Activities.” Each integration does that wrapping for you.
The OpenAI Agents SDK integration moved out of the Python SDK in September 2026. “Version 1.0.0 moves the integration out of the Temporal Python SDK,” so you install temporalio-openai-agents (1.1.0 on PyPI, Python 3.10 or later) and import temporalio.openai_agents instead of temporalio.contrib.openai_agents. The agent loop, tool selection and handoffs run inside the Workflow, “while model calls run as Activities.”
The Workflow is ordinary Agents SDK code:
from agents import Agent, Runner
from temporalio import workflow
@workflow.defn
class HelloWorldAgent:
@workflow.run
async def run(self, prompt: str) -> str:
agent = Agent(
name="Assistant",
instructions="You only respond in haikus.",
)
result = await Runner.run(agent, input=prompt)
return result.final_output
You register OpenAIAgentsPlugin on the Client, and “the plugin redirects Runner.run so that each model call becomes an Activity.” Conversation history lives in Workflow state: you “rebuild each turn’s input from the previous result.”
The other agent frameworks follow the same shape:
- Vercel AI SDK (TypeScript). Install
@temporalio/vercel-ai-sdkand addAiSdkPluginto the Worker. The older@temporalio/ai-sdkpackage now forwards to it. The plugin wrapsgenerateText()andstreamText()in Activities. - Pydantic AI.
pip install pydantic-ai[temporal], then attach theTemporalDurabilitycapability, which “routes model requests, tool calls, and MCP server communication through Temporal activities.” - Google ADK.
temporalio-google-adkruns “each model call and tool call as a Temporal Activity.” Temporal documents it for Python, Go and TypeScript. - Spring AI (Java). The
io.temporal:spring-aimodule sits next totemporal-spring-boot-starter, and model calls “run through Temporal Activities recorded in Event history.”
Temporal signal for human approval: Python SDK durable workflow
Temporal has three message types. “Signals are asynchronous write requests,” “Updates are synchronous, tracked write requests,” and Queries read state. Temporal’s Approval pattern uses a Signal: the Workflow blocks on workflow.wait_condition() until a handler sets the decision.
Trimmed from the docs, the Python version looks like this:
@workflow.defn
class ApprovalWorkflow:
def __init__(self) -> None:
self.approval_data: ApprovalData | None = None
@workflow.run
async def run(self, request_id: str, timeout_seconds: int) -> str:
await workflow.wait_condition(
lambda: self.approval_data is not None,
timeout=timedelta(seconds=timeout_seconds),
)
return f"Request {request_id} {self.approval_data.decision}"
@workflow.signal
def submit_approval(self, data: ApprovalData) -> None:
self.approval_data = data
Pick an Update instead when the approver’s screen needs an answer back, since “the sender of the Update can wait for a response.” In the OpenAI Agents SDK integration, a HostedMCPTool with require_approval calls your on_approval_request callback, which “can wait on a Signal or Update to get the answer from outside.”
Temporal delivers the decision. The approve button, the Slack message and the audit row are yours to build. For the wider pattern, see human-in-the-loop approvals for AI agents.
For a full build of the agentic loop as a Workflow, with model calls as Activities, tool calls as child Workflows, and approvals, see Temporal AI Agents: Building the Agentic Loop as a Workflow.
Temporal SDK release 2026: Python, TypeScript, Go, Java and Ruby
Temporal lists SDKs for Go, Java, .NET, PHP, Python, Ruby, Rust and TypeScript. The latest releases, from each registry:
| SDK | Package | Latest | Released | Needs |
|---|---|---|---|---|
| Python | temporalio | 1.36.0 | November 11, 2026 | Python 3.11 or later |
| TypeScript | @temporalio/client | 1.25.0 | October 27, 2026 | Node 20.3 or later |
| Go | go.temporal.io/sdk | v1.51.0 | November 10, 2026 | |
| Java | io.temporal:temporal-sdk | 1.40.0 | September 29, 2026 | |
| Ruby | temporalio gem | 1.11.0 | November 10, 2026 | Ruby 3.3 or later |
| .NET | Temporalio | 1.22.0 | November 10, 2026 |
The Ruby SDK went GA on October 1, 2025, when Temporal announced “the fully-featured Temporal Ruby SDK is generally available.” The Java SDK is Apache-2.0, and the others listed here are MIT.
Temporal Worker Versioning: pinned and auto-upgrade Workflows
Every time you change an agent’s prompt handling or tool logic, you change Workflow code that running executions replay. Temporal’s answer is Worker Versioning, and its docs say “prefer Worker Versioning over patching.”
You give each Workflow type one of two behaviors:
- Pinned. “Each execution runs entirely on the Worker Deployment Version where it started,” so old agent runs finish on old code.
- Auto-Upgrade. The Workflow moves to the new version when you change the current one, and you keep it replay-safe “manually, that is with patching.”
A ramping version takes “a configurable percentage of Workflows,” so a new agent loop can start on a slice of traffic. Self-hosted, you need Temporal Server v1.29.1 or later, and the SDK minimums start at Python 1.11, TypeScript 1.12 and Go v1.35.0.
Temporal self-hosted requirements: PostgreSQL, Elasticsearch and server 1.32
The Temporal Server is “four independently scalable services”: Frontend, History, Matching and Worker. It’s MIT-licensed, and the latest release is v1.32.2 (November 2, 2026).
It needs two stores:
- A persistence database. Temporal tests “PostgreSQL 13.18, 14.15, 15.10 and 16.6,” “MySQL v5.7 and v8.0,” and Cassandra. SQLite is “meant only for development and testing.”
- A Visibility store, which “is required” for the Web UI and CLI. PostgreSQL 12 or later and MySQL 8.0.17 or later work, and Elasticsearch or OpenSearch is “recommended for any setup that spawns more than a few Workflow Executions.”
The Docker Compose setup in temporalio/samples-server starts PostgreSQL and Elasticsearch, with the gRPC Frontend on port 7233. Schema upgrades are your job: with the temporalio/server image, “you have to manually manage schema updates” through temporalio/admin-tools. And the docs ask you to secure the service “similarly to a database.”
For local work, brew install temporal and temporal server start-dev start a development server.
Temporal Cloud pricing: actions per million
Temporal Cloud bills Actions, storage and a support plan. Actions start at “$50 per million,” and “self service” volume pricing goes “down to $25 per million actions.” New accounts get “$150 credits for 90 days.”
The plan sits on top of usage:
- Developer: “the greater of $0/month or 10% of your Temporal Cloud consumption.”
- Business: “the greater of $500/month or 10%,” with 2.5M Actions included.
Actions cover “starting Workflows, recording a Heartbeat or sending messages,” so each approval Signal counts. Storage is “$0.042/GBhr Active” and “$0.00105/GBhr Retained.” For the full math against running it yourself, see Temporal Cloud vs self-hosted cost.
What does Cadenya offer that Temporal doesn’t?
Temporal makes your agent code durable, and the agent loop is still yours to write, version and run. Cadenya is the agent loop itself, hosted, with approvals, conversation state, resume and model swap built in. Here’s what that covers:
- The loop, already written. Cadenya calls the model, runs the tools from your tool sets, streams each event, and compacts the context window from the variation’s compaction config or on demand.
- Approvals as a tool setting. Mark a tool as needing approval, and Cadenya “parks the Agent loop until it receives approval or a denial with optional steering.” Your backend handles
toolApprovalRequestedand approves or denies, and a denial carries a memo the agent reads. Several tools can wait at once. - Conversation state and resume. Every objective carries a durable event log of its agent loop. List stored events, or stream new ones over server-sent events and resume with the last event ID. A waiting objective picks up again with a Continue message.
- Model swap with no deploy. The model is a setting on an agent variation, not Worker code. Connect your own AI provider keys, pay the provider directly, and let weighted variations favor whichever variation scores well.
- Edits that leave running work alone. An objective keeps its variation’s configuration snapshot even after you edit the variation, so there’s no Worker Deployment Version to pin and no patch to write.
- Duplicate protection by design. An External ID on an objective prevents duplicates for a workflow or record in your app, and you can fetch the objective by that ID.
- Your app stays a web tier. The loop runs on Cadenya, so the Temporal Service, the Visibility store, the Workers and the schema upgrades all drop off your list.
- SDKs for TypeScript, Python, Ruby and Go, all at 1.9.0 under Apache-2.0. The TypeScript SDK (Node 18 or later) has shipped 113 versions since April 2026, and the Python SDK runs on Python 3.9 or later.
- A price in one line. Free for 1,000 loops a month, Growth at $49 a month for 50,000, then $0.0015 a loop. A loop is one LLM request made during an objective.
Approve or deny tools walks through the approval flow, 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 explains. To create an account, sign up at app.cadenya.com/signup, then copy your API key from the API keys page at app.cadenya.com/account/apiKeys.
Related articles
- Durable AI agents in Django with Celery (2026)Django
- Pydantic AI agents in production (2026)Pydantic AI
- Inngest vs Temporal for AI agents (2026)Durable execution
Grow wherever AI goes next.
Start shipping agents that are equipped to evolve.