architecture/execution

Host Applications compose a Lash runtime, open a session, and drive turns through one selected protocol plugin. Lash owns the reusable execution contract; each host owns bootstrap, configuration, presentation, and operational policy.

Host-to-runtime flow

The facade is the application boundary. Hosts provide already-materialized providers, stores, plugins, model selection, and protocol choice.

One turn
flowchart LR Host["Host Application"] --> Builder["LashCoreBuilder"] Builder --> Core["LashCore"] Core --> Session["LashSession"] Session --> Turn["TurnBuilder"] Turn --> Protocol["selected protocol plugin"] Protocol --> Provider["provider"] Protocol --> Tools["tools + plugins"] Turn --> Result["events + TurnReport"] Result --> Host 
let core = lash::LashCore::standard_builder(lash::TurnBudget::Unbounded)
    .provider(provider)
    .model(
        lash::ModelSpec::builder("anthropic/claude-sonnet-4.6")
            .context_window_tokens(200_000)
            .build()
            .expect("valid model metadata"),
    )
    .store_factory(store_factory)
    .effect_host(std::sync::Arc::new(
        lash::durability::InlineEffectHost::default(),
    ))
    .attachment_store(std::sync::Arc::new(
        lash::persistence::FileAttachmentStore::new(data_dir.join("attachments")),
    ))
    .process_env_store(process_env_store)
    // Start bounded; tune both limits for your backend's latency envelope.
    .commit_budget(lash::CommitBudget::bounded(1024 * 1024, 512))
    .queued_work_batching(lash::QueuedWorkBatchingConfig::new(1024))
    .build(crate::example_process_owner())?;

let session = core.session(chat_id).open().await?;
let result = session
    .turn(TurnInput::text(user_text))
    .stream_to(&events)
    .await?;

Execution-mode ownership

Standard

lash-protocol-standard exposes native tool schemas to the provider and advances the turn from provider tool calls and results.

RLM

lash-protocol-rlm interprets model-produced Lashlang blocks through lash-lashlang-runtime, preserving the same runtime tool, process, and persistence boundaries.

Modes are protocol plugins, not CLI branches. A custom host can select either mode or register another protocol implementation.

Application policy stays outside

The SDK does not load a product config file, select a terminal UI, implement slash commands, or decide how a product installs and updates. Each Host Application documents those choices in its own repository.