LanguageEN繁
Home
Docs
Open-source agent runtime + SDK

Build agentic experiencesinto your product.

Heddle gives product teams reusable agent execution: durable conversations, tools and MCP, approvals, background work, artifacts, and agent run management. Embed the runtime in your backend today, or place it behind a compatible Execution Host when the agent needs its own isolated environment. Your product keeps control of identity, data, policy, effects, and UI.

Start with the SDK
See integration shapes
Try the Heddle coding agent

Integration shapes

From direct embedding to isolated execution.

Embed Heddle directly in your backend. Add Agent Run Management when clients need stable run IDs, streaming, replay, cancellation, approvals, or reconnection. Move the same runtime behind a compatible host only when execution needs its own process, language-neutral interface, trust boundary, or isolated workstation.

Start here

Public · Open source

Embedded Runtime

Import Heddle directly into your TypeScript or Node.js backend. Your product owns the surrounding execution lifecycle, tools, storage, credentials, policy, product state, and UI.

@heddleagent/runtime

Optional lifecycle layer

Public · Open source

Agent Run Management

Heddle still runs in your own server or worker. Give each execution a stable run identity and reusable lifecycle for streaming, replay, cancellation, approvals, reconnection, and terminal settlement. Your product still owns the process and infrastructure.

@heddleagent/runtime/runs

Optional deployment boundary

Public adopter contract · Private reference implementation

Separate Execution Host

Run the same Heddle runtime in a separately deployed, isolated environment and invoke it through a language-neutral contract, without giving the runtime your product database credentials.

@heddleagent/execution-host-client

The Execution Host adopter contract and integration packages are public. The current compatible host and managed AgentCore deployment are private research. Heddle does not currently offer a public managed Execution Host or cloud service.

See the full component model

Clear responsibility boundaries

Reuse the runtime. Keep the product.

Heddle handles reusable agent mechanics without becoming your application framework or taking over your product decisions.

Heddle SDK owns

  • Persisted multi-turn conversations, continuation, compaction, and session behavior
  • Model and tool loops, native tools, Agent Skills, and curated MCP capabilities
  • Approval lifecycle, semantic activity, traces, artifacts, and typed turn results
  • Stable run identities, ordered events, replay, cancellation, approvals, and terminal settlement

Your product owns

  • Identity, tenancy, access rules, and who is allowed to approve
  • Canonical product records, relationships, retention, encryption, backup, and compliance
  • Product tools, system context, models, credentials, capability policy, and external effects
  • API, deployment, transport, UI, and how results become true in the product

Runtime foundations for real products.

The reusable mechanics between a model call and an agentic experience people can trust.

U
Research this topic and prepare a cited brief.
H
Running tools and preserving context...

Durable Conversations

Persist sessions across turns, resume work later, compact long histories, and keep conversation behavior consistent as your product grows.

page.tsx
12<Button onClick={submit}>
13- <span>Submit</span>
13+ <Loader className="animate-spin" />
14</Button>
Approved

Approvals & Traceable Activity

Pause for product-owned decisions and expose understandable activity, traces, artifacts, tool outcomes, and safe typed failures.

native tools + MCP

Tools, Skills & MCP

Bring native product tools, reusable Agent Skills, and curated MCP-backed capabilities into one host-controlled execution model.

agent service
web client
mobile
replay
approval
worker

Agent Run Management

Keep Heddle in infrastructure you operate while giving each execution a stable run identity, ordered events, replay, cancellation, approval resolution, reconnection, and one truthful terminal outcome.

Case studies

What real integrations taught Heddle.

These case studies document where Heddle has been tested inside real products—what worked, what changed, and where the product/runtime boundary belongs. Some describe current research systems; others preserve lessons from historical deployments.

Hosted execution proof

Lucid

Experimental deployment · observed hosted execution

An experimental delegated-discovery workspace where one personal Agent follows an Interest, checks for useful information, and returns grounded Findings or an explicit no-action outcome.

An agent that wakes after the user leaves.

Lucid proved that a product-owned personal Agent could wake on schedule, enter an isolated Heddle runtime, inspect only a fixed product scope, and settle truthfully—even when there was no useful Finding to return.

  • Scheduled work without an open browser
  • Scoped product access without database credentials
  • Durable claims, recovery, and truthful settlement
Read the hosted execution case study
Diagram showing a Lucid Agent waking on schedule after the browser closes and settling with no new Finding
The deployed proof crossed a timer-due Coordinator claim, managed isolated Runtime, fixed Lucid event horizon, scoped tools, and a truthful no-finding settlement without foreground interaction.

Integration retrospective

SlideX

Historical deployment · first third-party integration

A browser presentation workspace that integrated a conversational agent for creating and revising real decks.

What SlideX taught Heddle about becoming a product SDK.

In July 2026, SlideX deployed a Heddle-powered conversational presentation agent. The hosted product has since been retired as SlideX moved back toward local operation, but the integration became the pressure test that reshaped Heddle into a reusable SDK.

  • Integrated real presentation tools
  • Proved durable multi-turn conversations
  • Shaped Heddle's public SDK boundaries
Read the integration retrospective
SlideX editor showing a presentation beside a multi-turn conversation with the SlideX Agent
Captured during the July 2026 deployment: a real SlideX conversation asks the agent to restyle a slide, add SDK content, and insert a section header.

working/NOW.md

Current focus, evidence, open questions, and the next sensible move.

memory/

Stable preferences, conventions, and durable user knowledge.

Next wake

Recover, reconsider, act within authority, or honestly do nothing.

Research direction

Research in progress · not a shipped Heddle feature

Can one assistant stay useful across long-running projects?

The Assistant is testing whether an intelligent model, durable working files, separate long-term memory, bounded tools, and a reliable wake lifecycle can produce useful proactive behavior without encoding a workflow for every domain.

  • Recover work after a cold Runtime
  • Choose action, approval, or no action
  • Transfer across unrelated domains
Read the research hypothesis

Reference product

See the same runtime in a complete product

Heddle's local coding agent, terminal UI, and browser control plane are built on the same conversation and run foundations exposed through the SDK. The coding agent is a reference product and dogfood surface, not the whole Heddle product boundary.

Build the agentic experience
your product needs.

Start with the open-source runtime, keep control of your product, and adopt only the Heddle runtime and execution layers your experience needs.