Heddle documentation
Build an agentic experience with Heddle
Start with a working conversation, then adopt only the runtime, capability, hosting, and client layers your product actually needs.
Customization depth
Choose the smallest useful runtime boundary
Hosting depth
In-process, hosted, remote, or product UI
Documentation status
Supported SDK boundary
- Durable conversation and turn semantics
- Model and tool execution, approvals, traces, and artifacts
- Ordered active runs, replay, cancellation, and terminal outcomes
- Identity, tenancy, authorization, and product relationships
- Domain tools, model credentials, storage policy, and public schemas
- Server framework, transport, deployment, UI, and result application
See it in a real product
Heddle is already doing real work inside SlideX.
Follow the complete product story before choosing the Heddle layers that fit your own application.
Product case study
SlideX
Working product integrationA browser workspace for creating, editing, and exporting professional presentations.
Turn an idea into slides through conversation.
SlideX makes it easier to create polished presentations. Heddle powers the conversational agent that lets users describe an idea, refine it together, and turn it into slides inside the editor.
- Describe an idea
- Build and revise slides
- Continue the conversation
Choose the path that matches your product
| What you want to do | Start here | What you will own |
|---|---|---|
| Evaluate Heddle in a TypeScript process | Build your first agent | Configuration and prompts |
| Add Heddle to an existing backend | Choose an integration layer | Product composition and the boundaries you already have |
| Add domain tools or an MCP server | Add a native tool or connect MCP | Domain behavior and capability policy |
| Render the agent inside your own application | Own output and activity | Presentation, UI state, and result handling |
| Let a turn outlive one request | Hosting overview | Identity, address scope, process lifetime, and transport |
| Build a browser product | Remote client | Public schemas, reconnect UX, and product UI state |
| Try the complete reference product locally | Local quickstart | A workspace and model access |
Learn in two dimensions
Heddle does not force one application stack. Decide two things independently:
- Customization depth: begin with a complete prompt loop, then progressively own capabilities, output, lifecycle, policy, and persistence.
- Hosting depth: stay in one process, add addressable runs, expose a transport, or connect a remote product UI.
The integration-layer chooser maps those decisions to the smallest public package surface that fits.
Recommended first journey
Follow the numbered Build with the SDK pages in order if you are learning Heddle:
- Run one persisted conversational agent.
- Create a stable session and submit a second turn.
- Add one product-owned tool.
- Add MCP only when the capability already exists behind a server.
- Move system behavior beside the capability that needs it.
- Replace the default text output with your own application surface.
- Consume structured results, then connect approval policy when a capability needs a decision.
- Add artifact and storage adapters only when the product requires them.
You can stop at any useful rung. Hosting and browser layers are optional.
The local coding agent is the reference host
Heddle's terminal UI and browser control plane exercise the same conversation, activity, approval, trace, and run foundations exposed through the SDK. Use them to learn what Heddle can do, then build a product experience with only the layers you need.