Skip to content
larkx.

Open-source infrastructure for edge AI

Durable execution for on-device AI agents.

Build multi-step agents that preserve their progress, recover from interruptions, and coordinate execution across mobile devices, edge hardware and the cloud.

In development · Open‑source runtime planned · Model‑agnostic · Source on GitHub

LARKX / EXECUTION TRACEDEMO
AGENT / RUN_7F92
inspection-agent
RUNNING
◉ DEVICE · SQLite
◉ CLOUD · worker
Inspect imageDEVICE
Read local recordsDEVICE
Evaluate findingsDEVICE
Advanced reasoningCLOUD
Save inspection reportDEVICE

The agent has analyzed the image and recorded its first tool result.

Interactive concept simulation · not a live runtime

01OFFLINE-FIRST02DURABLE AGENT STATE03HYBRID ORCHESTRATION04BRING YOUR OWN COMPUTE

01 / The missing layer

Inference is becoming portable.
Agent execution is not.

Local models make edge intelligence possible. Multi-step agents introduce a different challenge: preserving decisions, tool results and execution progress when devices disconnect, suspend or terminate.

01 / INTERRUPTIONS

Devices are not servers.

App termination, memory pressure and limited background execution interrupt agent loops. Completed work should not disappear with the process.

02 / CONNECTIVITY

Offline is normal.

Local reasoning and tools should keep working without a reachable orchestration service, when the device permits execution.

03 / COORDINATION

One agent. Many environments.

Handing work to remote models and tools requires persistent dispatch, retry safety and a consistent execution history.

02 / Developer experience

Build agents.
Not recovery infrastructure.

A high-level agent API for fast adoption. A durable workflow API for complete control.

  • Record reasoning decisions and tool outputs
  • Replay committed steps after interruptions
  • Declare local, cloud or hybrid execution
  • Integrate existing inference frameworks

API Preview · TypeScript · initial target: React Native.

github.com/larkxai/larkx

import { createAgent } from "@larkx/agent";
import { cactusAdapter } from "@larkx/cactus";

const agent = createAgent({
  name: "inspection-agent",
  model: cactusAdapter(model),
  tools: [vision, records, report],
  durability: true,
});

await agent.run({
  input: "Inspect this equipment"
});

// On next app launch
await engine.recover();
TypeScript · API Preview

03 / Technology stack

The missing execution layer
in the edge AI stack.

Models provide intelligence. Agent frameworks decide what to do. LarkX is designed to make those multi-step decisions and actions durable across devices and the cloud.

06
AI applications
Deliver user-facing agent experiences.
Mobile appsField agentsRobotics
05
Agent orchestration
Reasoning loops, tool selection and agent control flow.
LangGraphCustom agentsLarkX Agents*
04
LarkX · Durable execution
Checkpoint, recover and coordinate complete agent workflows.
LarkX Runtime*LarkX Cloud*
03
Inference runtimes & APIs
Execute model inference locally or remotely.
CactusRunAnywhereOllamaLiteRT-LMllama.cppMLXCloud APIs
02
AI models
Language, vision, reasoning and multimodal capabilities.
GemmaQwenLlama
01
Compute & devices
Physical execution environments and accelerators.
iOS / AndroidEdge CPU / NPUCloud GPU

* Product Preview. Illustrative stack, not strict dependencies: some platforms span multiple layers. Named third-party technologies are examples, not confirmed integrations or partnerships.

MODEL-AGNOSTIC · LOCAL-FIRST

04 / Architecture

Local-first by design.
Cloud-connected by choice.

Unlike server-coordinated workflow engines, LarkX is designed to embed orchestration and execution history directly on the device.

Run locally. Manage globally.

The runtime owns the workflow journal. Models and tools remain replaceable. Remote steps are coordinated through a managed control plane, using the customer's own compute.

Recovery happens when the OS allows execution. Cloud handoff requires connectivity, compatible handlers and permission to transfer data.

EDGE / EMBEDDED

Device runtime

CLOUD / CUSTOMER

Remote workers

← ONE DURABLE EXECUTION ID →

Product Preview · LarkX Runtime

Low-level workflow primitives: named steps, checkpoints, replay, and a device-local execution journal.

05 / Competitive landscape

Beyond inference.
Beyond server-first orchestration.

Temporal made backend workflows durable. LarkX is bringing durable execution to the devices where agents increasingly run.

Architectural comparison of existing systems and LarkX's proposed distinction.
Existing solutionPrimary focusLarkX's proposed distinction
Temporal (opens in a new tab)Server-coordinated durable workflowsEmbedded offline agent orchestration
DBOS (opens in a new tab)Database-backed backend executionDevice-local SQLite and mobile lifecycle
Golem (opens in a new tab)Durable WebAssembly agent runtimeEmbedded mobile lifecycle and offline-first coordination
Restate (opens in a new tab)Durable service and agent executionDevice-local orchestration without a reachable service
LangGraph (opens in a new tab)Agent graphs and checkpointingDevice-first runtime and hybrid handoff
RunAnywhere (opens in a new tab)Local inference, agent loops and fleet toolingFocus on durable multi-step execution and recovery
PowerSync (opens in a new tab)Offline database synchronizationExecution history and operation recovery

Comparison of architectural focus, not an exhaustive feature audit. Existing systems can be integrated with LarkX. On small screens the table scrolls sideways.

Model-agnostic by design

Your inference engine runs your models.
LarkX runs your workflows.

Bring the inference engine you already use. LarkX is designed to preserve the decisions, tool results and execution state around it.

CactusRunAnywhereOllamallama.cppLiteRT-LMMLXApple Foundation Models

Illustrative integration targets, not shipped integrations or partnerships. Ollama is primarily a desktop/server runtime; availability varies by device.

06 / Business model

Open at the edge.
Managed at scale.

Free embedded execution drives developer adoption. A managed hybrid orchestration platform creates recurring revenue without reselling GPU compute.

Planned open-source core

LarkX Runtime

Free local execution. No mandatory cloud dependency.

  • Embedded durable workflow engine
  • Agent checkpointing and replay
  • SQLite persistence and recovery
  • Local model and tool integrations
  • React Native SDK

Planned commercial platform

LarkX Cloud

Managed orchestration for distributed agent execution.

  • Durable remote step dispatch
  • Device-to-cloud state coordination
  • Unified execution history
  • Fleet observability and recovery insights
  • Enterprise controls and support

07 / Initial markets

Where agents meet the real world.

Starting with mobile and desktop developers, expanding to enterprise, robotics, and IoT fleets where reliability and offline access matter.

FIELD / 01

Industrial inspection

Analyze equipment locally, gather evidence in dead zones, delegate complex reasoning when connectivity returns.

MOBILE / 02

Personal AI applications

Multi-step voice, vision and planning agents that recover after app closure rather than losing progress.

EDGE / 03

Robotics & gateways

Coordinate high-level AI workflows across constrained hardware and remote workers, separate from real-time safety control.

  • MOBILE
  • DESKTOP
  • ENTERPRISE
  • ROBOTICS
  • IOT

08 / Roadmap

From durable agents to
distributed intelligence.

PHASE 01 · FIRST MILESTONE

Embedded runtime

SQLite replay, React Native, process-death recovery and Cactus agent demo.

PHASE 02 · COMMERCIAL WEDGE

Hybrid orchestration

Persistent dispatch, cloud workers, reconciliation and hosted execution history.

PHASE 03 · EXPANSION

Distributed execution

Cross-device coordination, capability-aware scheduling and fleet management.

Building the next execution layer

The future of AI is distributed.
Make it reliable.

We're looking for developers building on-device agents, design partners with real hybrid execution challenges, and investors who share our vision.

artem.dudynskiy@gmail.com