Runtime Overview

A runtime is what actually executes your agents. Helix Agents provides multiple runtimes, each suited to different deployment scenarios. Your agent definitions work identically across all runtimes - only the execution environment changes.

What Is a Runtime?

The runtime orchestrates the agent execution loop:

1. Initialize agent state
2. Call the LLM with messages and tools
3. Execute any tool calls
4. Handle sub-agents
5. Persist state
6. Stream events
7. Repeat until completion

Different runtimes handle these steps differently based on their execution model.

Available Runtimes

Runtime	Package	Best For
JavaScript	@helix-agents/runtime-js	Development, testing, simple deployments
Temporal	@helix-agents/runtime-temporal	Production, long-running agents, durability
Cloudflare	@helix-agents/runtime-cloudflare	Edge deployment, serverless, global scale

Cloudflare Has Two Approaches

The Cloudflare runtime offers two execution models: Workflows (step-level durability with D1) and Durable Objects (unlimited streaming with built-in SQLite). See Cloudflare Runtime for comparison.

Comparison

Execution Model

Feature	JS Runtime	Temporal Runtime	Cloudflare Workflows	Cloudflare DO
Durability	None (in-memory)	Full (workflow persistence)	Step-level	Checkpoint-based
Crash Recovery	No	Yes	Yes (step-level)	Yes (checkpoint)
Timeout Handling	Manual	Per-activity timeouts	Per-step timeouts	Manual
Retry Logic	Manual	Automatic with config	Automatic per step	Manual
Multi-Process	No	Yes (workers)	Yes (edge nodes)	Yes (edge nodes)
Concurrency	Status check + OCC	Workflow ID uniqueness	Workflow instance	DO isolation

State & Streaming

Feature	JS Runtime	Temporal Runtime	Cloudflare Workflows	Cloudflare DO
State Store	Memory/Redis	Memory/Redis	D1 Database	DO SQLite
Stream Manager	Memory/Redis	Memory/Redis	Durable Objects	Direct WebSocket/SSE
Streaming Limit	None	None	1000 subrequests	Unlimited (FREE)
Stream Resumption	FrontendHandler	FrontendHandler	FrontendHandler	FrontendHandler
Content Replay	Built-in	Built-in	Built-in	Built-in
Sub-Agent Execution	In-process	Child workflows	Nested workflow calls	In-process

Operational

Feature	JS Runtime	Temporal Runtime	Cloudflare Workflows	Cloudflare DO
Infrastructure	None	Temporal Server	D1 + Workflow + DO	DO only
Complexity	Low	Medium-High	Medium	Low-Medium
Cost	Hosting only	Temporal Cloud or self-host	D1 + subrequests	DO duration only
Scaling	Vertical	Horizontal (workers)	Automatic (edge)	Automatic (edge)
Hibernation	N/A	N/A	No	Yes (cost savings)

Method Availability

All runtimes support the same executor methods:

Method	JS	Temporal	Cloudflare
execute()	✅	✅	✅
resume()	✅	✅	✅
retry()	✅	✅	✅
getHandle()	✅	✅	✅

Choosing a Runtime

Use JavaScript Runtime When:

• Development and testing - Fast iteration without infrastructure
• Simple deployments - Single-process, short-lived agents
• Prototyping - Explore ideas before production setup
• Serverless functions - Lambda/Cloud Functions where execution is short

import { JSAgentExecutor, InMemoryStateStore, InMemoryStreamManager } from '@helix-agents/sdk';

const executor = new JSAgentExecutor(
  new InMemoryStateStore(),
  new InMemoryStreamManager(),
  llmAdapter
);

Use Temporal Runtime When:

• Production workloads - Need reliability and observability
• Long-running agents - Execution may take hours or days
• Crash recovery - Agent must survive process restarts
• Complex orchestration - Multi-agent systems with dependencies

import { TemporalAgentExecutor } from '@helix-agents/runtime-temporal';

const executor = new TemporalAgentExecutor({
  client: temporalClient,
  stateStore: redisStateStore,
  streamManager: redisStreamManager,
  workflowName: 'agent_workflow',
  taskQueue: 'agents',
});

Use Cloudflare Runtime When:

• Global edge deployment - Low latency worldwide
• Serverless architecture - No servers to manage
• Cloudflare ecosystem - Already using Workers, D1, DO
• Cost optimization - Pay per request, automatic scaling

Workflows approach - Step-level durability, D1 integration:

import { CloudflareAgentExecutor } from '@helix-agents/runtime-cloudflare';

const executor = new CloudflareAgentExecutor({
  workflowBinding: env.AGENT_WORKFLOW,
  stateStore: d1StateStore,
  streamManager: doStreamManager,
});

Durable Objects approach - Unlimited streaming, simpler architecture:

import { AgentServer, DOAgentExecutor } from '@helix-agents/runtime-cloudflare';

export { AgentServer }; // Export DO class

const executor = new DOAgentExecutor({
  agentNamespace: env.AGENTS,
  createLLMAdapter: () => new VercelAIAdapter({ model: openai('gpt-4o') }),
});

See Cloudflare Runtime for detailed comparison of both approaches.

Common API

All runtimes implement the AgentExecutor interface:

interface AgentExecutor {
  // Execute an agent with input
  execute<TState, TOutput>(
    agent: AgentConfig<...>,
    input: string | { message: string; state?: Partial<TState> },
    options?: ExecuteOptions
  ): Promise<AgentExecutionHandle<TOutput>>;

  // Reconnect to existing session
  getHandle<TState, TOutput>(
    agent: AgentConfig<...>,
    sessionId: string
  ): Promise<AgentExecutionHandle<TOutput> | null>;
}

The returned handle provides:

interface AgentExecutionHandle<TOutput> {
  runId: string;

  // Stream real-time events
  stream(): Promise<AsyncIterable<StreamChunk> | null>;

  // Wait for final result
  result(): Promise<AgentResult<TOutput>>;

  // Cancel execution
  abort(reason?: string): Promise<void>;

  // Get current state
  getState(): Promise<AgentState<unknown, TOutput>>;

  // Check if resumable
  canResume(): Promise<CanResumeResult>;

  // Resume execution
  resume(options?: ResumeOptions): Promise<AgentExecutionHandle<TOutput>>;
}

Swapping Runtimes

Because all runtimes share the same interface, swapping is straightforward:

// Development
const executor =
  process.env.NODE_ENV === 'production'
    ? new TemporalAgentExecutor({
        /* production config */
      })
    : new JSAgentExecutor(memoryStore, memoryStream, llmAdapter);

// Same usage regardless of runtime
const handle = await executor.execute(myAgent, 'Research AI agents');
const result = await handle.result();

This is the core philosophy of Helix Agents: define once, execute anywhere.

Next Steps

• JavaScript Runtime - In-process execution details
• Temporal Runtime - Durable workflow execution
• Cloudflare Runtime - Overview and comparison
  • Workflows Runtime - D1 + Workflows approach
  • Durable Objects Runtime - Direct DO approach
• Storage Overview - State stores and stream managers