Crate everruns_runtime 

The agentic runtime — the in-process entrypoint to the Everruns agentic framework.

The runtime crate exposes an in-memory execution surface that runs the same core atoms (input, reason, act) used elsewhere in the system, but without the durable engine, gRPC worker boundary, or control-plane server. It is part of the Everruns ecosystem.

This is the agentic framework entrypoint for embedders who want to:

• run sessions in their own process
• provide their own platform definition (capabilities, drivers, harnesses)
• seed harnesses, agents, sessions, and workspace files directly in code
• replace the default in-memory stores with custom runtime backends
• inspect the assembled turn context before or after executing a turn
• reuse runtime-owned host phase execution from durable or server-backed hosts
• map plan_next_host_turn(...) onto their own queue, retry, or in-memory host

InProcessRuntimeBuilder::new() starts from a runtime-safe built-in capability registry. Hosted Everruns product capabilities and capabilities that require optional host backends can still be enabled by supplying an explicit PlatformDefinition.

For a runnable example, see:

cargo run -p everruns-runtime --example in_process_runtime
cargo run -p everruns-runtime --example inspect_context

Example

use everruns_core::{
    CapabilityRegistry, DriverRegistry, InputMessage, DriverId, ResolvedModel,
    PlatformDefinition,
};
use everruns_core::capabilities::TestMathCapability;
use everruns_runtime::InProcessRuntimeBuilder;

let mut capabilities = CapabilityRegistry::new();
capabilities.register(TestMathCapability);

let platform = PlatformDefinition::new(capabilities, DriverRegistry::new());

let runtime = InProcessRuntimeBuilder::new()
    .platform_definition(platform)
    .single_session(|s| {
        s.harness("math", "You are a calculator.")
            .harness_display_name("Math")
            .with_capability("test_math")
            .agent("math-agent", "Use tools when needed.")
            .agent_display_name("Math Agent")
            .agent_max_iterations(8)
            .session_title("Math Session")
    })
    .llm_sim(everruns_core::llmsim_driver::LlmSimConfig::fixed("4"))
    .default_model(ResolvedModel {
        model: "llmsim-model".into(),
        provider_type: DriverId::LlmSim,
        api_key: Some("fake-key".into()),
        base_url: None,
        provider_metadata: None,
    })
    .build()
    .await?;

let session_id = runtime.default_session_id().expect("single_session id");
let result = runtime
    .run_turn(
        session_id,
        InputMessage::user("What is 2 + 2?"),
    )
    .await?;
assert!(result.success);

Real-disk workspace

Embedders who want built-in capabilities (file_system, agent_instructions, skills, …) to read and write a real directory on disk can configure RealDiskSessionFileSystemFactory on their PlatformDefinition. Every capability that goes through ToolContext.file_store or SystemPromptContext.file_store picks it up automatically.

See the runnable examples for the full wiring:

cargo run -p everruns-runtime --example real_disk_agent_instructions
cargo run -p everruns-runtime --example real_disk_file_system_tools

And knowledge/runtime-resources/file-store.md for the trait contract.

Structs

AgentBuilder

Builds an Agent with runtime-friendly defaults.

ApprovalGatingFileStore

Gate destructive operations through an embedder-supplied FileApprovalGate. Reads pass through.

AssembledTurnContext

Public snapshot of the assembled turn context used by reason-phase hosts.

CapabilityDelta

Result of changing the session-scoped capability set of a live runtime.

HarnessBuilder

Builds a Harness with runtime-friendly defaults.

InMemorySessionFileStore

In-memory implementation of the session virtual filesystem.

InMemorySessionFileSystemFactory

Factory for the runtime’s in-memory session filesystem.

InMemorySessionStorageStore

In-memory implementation of session key/value and secret storage.

InMemorySessionStore

In-memory SessionStore + SessionMutator for embedded runtimes.

InProcessRuntime

Public in-process runtime backed by either in-memory or custom stores.

InProcessRuntimeBuilder

Builder for the public in-process runtime.

RealDiskFileStore

A SessionFileSystem rooted at a real host directory.

RealDiskSessionFileSystemFactory

Factory for real-disk session files rooted at a fixed host directory.

RuntimeActPlan

Engine-owned act scheduling payload.

RuntimeBackends

Non-filesystem backend bundle supplied to the embedded runtime.

RuntimeHostTurnContext

Turn context loaded in one batched call for runtime host execution.

RuntimeSessionLifecycle

Shared lifecycle helper for runtime-backed hosts.

RuntimeTurnState

Host-owned state carried across turn phases.

SessionBuilder

Builds a Session with runtime-friendly defaults.

SingleSessionBuilder

High-level builder for seeding one harness, one agent, and one session.

TurnResult

WriteBlocklistFileStore

Reject writes into vendored / build directories at any depth.

Enums

RuntimeTurnPlan

Generic next-step decision for a host turn.

TaskTransition

A task lifecycle transition an observer can be notified of.

TurnStopReason

Stable reason a turn stopped, independent of provider-specific strings.

Constants

DEFAULT_WRITE_BLOCKLIST

Default vendored / build directory names that WriteBlocklistFileStore rejects writes into. Embedders can override via with_blocklist.

Traits

EventBus

Event sink that supports emission and optional collection.

FileApprovalGate

Embedder-supplied approval callback used by ApprovalGatingFileStore.

RuntimeAgentStore

Agent store contract for runtime seeding and lookup.

RuntimeHarnessStore

Harness store contract for runtime seeding and lookup.

RuntimeHostAdapter

Public adapter contract for server-backed or durable runtime hosts.

RuntimeMessageStore

Message store contract for runtime persistence and lookup.

RuntimeProviderStore

Provider store contract for runtime lookup and default-model configuration.

RuntimeSessionStore

Session store contract for runtime seeding, lookup, and mutation.

TaskTransitionObserver

Receive task-transition notifications in process.

Functions

detect_dependency_blocker

execute_act_activity

execute_input_activity

execute_reason_activity

execute_reason_activity_with_prompt_messages

Execute a reason activity while applying user_prompt_submit hooks to the supplied messages. Hosts that inject synthetic user messages between reason iterations must include their ids here so they cross the same policy boundary as the turn’s original input.

in_process_internal_org_id

Derive an internal i64 org id from the public org_<32hex> form on a Session.

multi_root_file_system

plan_next_host_turn

Determine the next host step after an activity finishes.

Type Aliases

PlatformStoreFactory

Factory producing a per-(org, session) PlatformStore. The session id is supplied because platform stores are scoped to the calling session for subagent spawning and platform-management tools.

ScheduleStoreFactory

Factory producing a per-org SessionScheduleStore. Embedders that have a single global store can ignore the org_id argument and return the same Arc every time.