Heddle hosted execution adopter
Experimental deployment · observed hosted executionLucid proved that agent work can continue after the user leaves
A powerful local harness is not yet a product service. Lucid became the pressure test for the missing production boundary: durable scheduling, isolated execution, narrow product authority, recovery after process loss, and a user-facing outcome that never confuses silence with success.
Current status · September 2026
Lucid is an experimental personal-agent deployment and engineering proof, not a publicly available product or managed Heddle service. The evidence below was observed through September 2, 2026 in the deployed Lucid, Coordinator, and managed Runtime stack.
By Jay / Fienna LiangPublished Updated
- Product
- Personal delegated-discovery workspace
- Execution
- Coordinator-scheduled isolated Heddle Runtime
- Outcome
- Background work without an open browser
A local agent loop is not a deployable product boundary
A local harness can run tools and preserve a conversation, but product autonomy creates a different set of obligations. The work needs a durable owner, a bounded view of current product state, a way to survive process replacement, and a terminal result the product can trust after the browser and original request are gone.
Lucid also could not solve this by giving the Runtime its database credentials or copying product policy into a generic scheduler. Lucid had to remain authoritative for users, Interests, messages, Findings, event horizons, idempotent effects, and what the UI calls complete. Heddle and the Execution Host had to own the reusable execution mechanics without becoming the product.
What the user-visible loop had to prove
The goal was not to make a background process look busy. The Agent had to preserve continuity, act only on authorized state, and remain quiet when nothing useful changed.
- A user can save an Interest, leave the browser, and let scheduled checks continue independently.
- A foreground Check now request and a timer-due wake enter the same durable product-work lifecycle.
- Each attempt reads a fixed event horizon rather than an unbounded changing world.
- The Agent records a grounded Finding, bounded communication, or an explicit no-finding outcome.
- Failures and interruptions retain unread product work instead of advancing the cursor optimistically.
- The product presents understandable Activity rather than raw scheduler or model traces.
Scheduling, execution, and product truth stayed separate
The deployed path composed three owners. Each one enforced a different fact instead of sharing one oversized control plane.
- 01Identity + product truth
Lucid product
Owns users, Interests, event horizons, Findings, product tools, durable effects, cursor advancement, authenticated UI, and the meaning of completion.
- 02Durable work ownership
Heddle Coordinator
Owns schedules, run requests, claims, fencing, recovery, bounded concurrency, checkpoints, and final Heddle task settlement.
- 03Isolated execution
Execution Host Runtime
Verifies signed scope, runs one bounded Heddle model/tool loop, streams ordered activity, handles cancellation, and receives no Lucid database credential.
The execution service did not become the product
Lucid exposed only the product facts and effects required by one claimed attempt. Heddle supplied the general lifecycle and the Execution Host supplied the isolated place to execute it.
- Durable task scheduling, run requests, claims, leases, fencing, recovery, and checkpoints
- One bounded model/tool execution with cancellation and a truthful terminal outcome
- Signed execution identity and exact invocation-scoped MCP capability
- Isolation of temporary files and processes from the product backend
- Public adopter contracts without requiring the adopter to import private host code
- User and Agent identity, authenticated product routes, and product policy
- Canonical events, current Interest, fixed work horizon, and unread cursor
- Product MCP schemas, visibility rules, validation, and idempotent effects
- Finding, communication, no-action, retry, and product settlement semantics
- User-facing Activity and every product UI decision
Lucid turned adopter friction into reusable runtime contracts
The integration repeatedly exposed lifecycle code that would otherwise be rebuilt inside each product. Generic correctness moved into Heddle or the Execution Host; Lucid-specific meaning stayed in Lucid.
Reusable mechanics strengthened by the integration
- Durable run requests that coalesce without losing newer intent
- Claim identity, stale-writer fencing, interrupted-work recovery, and bounded concurrency
- Awaitable cancellation and shutdown through the final persistence boundary
- Scoped admission and fail-closed resume preparation
- Checkpoint-before-success ordering and isolated hosted invocation contracts
Domain behavior deliberately kept in Lucid
- Which product events are visible to one Agent and one execution
- What counts as a valid Finding, response, working-note update, or no-action result
- How effects are deduplicated and how the product cursor advances
- How paused, failed, retryable, waiting, and completed states appear to the user
What the deployed proof actually observed
The strongest evidence was not a polished chat demo. It was correlated behavior across durable product state, the Coordinator, a managed isolated Runtime, scoped tools, and terminal settlement.
- Two consecutive timer-due wakes started without Check now, foreground Chat, or an open browser.
- Both attempts restored the existing checkpoint, inspected only their frozen Lucid scope, and settled as No new Finding instead of inventing activity.
- The scheduled starts followed their persisted due times by roughly one second or less.
- A scoped pause and resume excluded events committed during the closed window and admitted only events after Lucid's durable resume boundary.
- A local fault-injection proof killed the Coordinator during preparation; a replacement recovered the same transition without opening admission early.
- Stale executions could not write or settle product work after ownership transferred.
Build a similar experience
Turn a capable runtime into product-owned delegated work
Heddle provides the reusable agent and lifecycle mechanics. Your product still defines whose work it is, what the agent may observe and change, and when the result becomes true.