Modules
Public facade for Jidoka.
Authoring API for an Elixir action that an agent can use as a tool.
Runtime support for executing Jido actions as Jidoka operations.
Formal Jidoka state contract stored inside a process-hosted Jido agent.
ReqLLM runtime support for Jidoka's LLM effect boundary.
Minimal Spark DSL for defining a Jidoka agent on top of Jido.
Durable chat message stored on agent state.
Canonical immutable definition of a Jidoka agent.
Policy controls attached to a Jidoka agent definition.
Control attached to the input boundary.
Policy control attached to model-callable operations.
Control attached to the final output boundary.
Provider-facing generation defaults for an agent.
Conversation memory policy for an agent.
Model-callable operation definition.
Structured app-facing result contract for an agent.
Durable semantic state for an agent session.
Surface-neutral UI projection contract for a Jidoka agent.
Module contract for dynamic operation approval predicates.
Constrained browser tool source backed by jido_browser actions.
Typed evidence that an asynchronous Jidoka request was cancelled.
Data handle for an asynchronous Jidoka chat request.
Runtime configuration helpers for Jidoka.
Provider-neutral text and media content for requests, messages, and results.
Canonical runtime context passed to Jidoka policy code.
Minimal reusable policy control contract for Jidoka agents.
Built-in input-size control.
Built-in operation control used by approval sugar.
Built-in control that requires application context keys to be present.
Data-first request debug and replay diagnostics.
Diagnostic view for replayable Jidoka runtime data.
Request-level debug summary assembled from Jidoka runtime data.
Data description of an external effect the runtime may interpret.
Intent/result journal used to make effects replayable.
Typed model-side decision returned by an LLM effect.
Typed request payload for an operation effect.
Durable operation observation stored on agent state.
Normalized result of an interpreted effect.
Splode-backed error helpers for Jidoka.
Configuration error class for Splode.
Invalid Jidoka configuration error.
Runtime execution error class for Splode.
Jidoka runtime execution error.
Internal error class for Splode.
Invalid input error class for Splode.
Invalid input or schema validation error.
Small deterministic eval runner for Jidoka turn flows.
Deterministic evaluation case for one Jidoka turn.
Result of running a Jidoka.Eval.Case.
Core event emitted by Jidoka turn transitions.
Portable JSON/YAML export for Jidoka.Agent.Spec.
Data contract for conversation ownership transfer.
Storage boundary for conversation handoff owners.
Supervised ETS-backed handoff owner store for local runtimes, examples, and tests.
Small boundary for generated Jidoka identifiers.
JSON/YAML import runtime for data-authored Jidoka agents.
Portable JSON/YAML authoring document for a Jidoka agent.
Inspection and preflight helpers for Jidoka's data-first runtime.
Data returned by Jidoka.preflight/3.
Resolves instructions for one agent request.
Default Jido runtime instance for Jidoka agents.
Optional Livebook helpers for inspecting and demonstrating Jidoka agents.
Data contracts and runtime helpers for visible agent memory.
Durable memory entry available to prompt assembly.
Request sent to a memory store before prompt assembly.
Memory entries recalled for a turn.
Behaviour and delegator for agent memory stores.
In-memory memory store for deterministic tests and examples.
Jidoka.Memory.Store adapter backed by jido_memory.
Request to write one memory entry.
Result returned after writing memory.
Routes, retries, and falls back model calls at the LLM effect boundary.
Runtime-neutral operation execution port.
Behaviour and compiler for operation sources.
Operation source backed by a Jido.Action.Catalog.
Operation source for conversation handoff ownership.
Operation source backed by one or more Jido Action modules.
Local operation source backed by Elixir functions.
Operation source backed by jido_mcp.
Operation source for bounded subagent delegation.
Operation source for deterministic Jidoka workflows.
Durable human-review data contracts.
Durable pause point produced by a runtime control.
Policy describing when a model-requested operation must pause for review.
Application-facing request for human review of an interrupted operation.
Application response to a pending review request.
Advanced extension contract for injected LLM and operation capabilities.
Runtime context passed to controls at the operation boundary.
Runtime support for executing local Elixir functions as Jidoka operations.
Ergonomic session facade backed by Jidoka.Session.Data.
Serializable session envelope for running an agent across requests.
Durable ownership token for one active session continuation.
Durable parentage for a session created from a safe snapshot fork.
Inspection-friendly replay projection for stored session data.
Behaviour and delegator for durable session storage.
Disk-backed, lease-aware session store built on Erlang DETS.
In-memory session store for tests, examples, and local exploration.
Pure durable session state transitions.
Public helpers for Jido AI skills used by the Jidoka DSL.
Serializable semantic snapshot for hibernate/resume.
Request-scoped stream helpers for Jidoka turn events.
Trace projection helpers for Jidoka runtime events.
Trace projection policy.
Behaviour and delegator for trace sinks.
In-process trace sink for tests, examples, and local inspection.
Pointer to the next safe phase boundary.
Executable data compiled from Jidoka.Agent.Spec.
Input for one agent turn.
Final app-facing result of one Jidoka turn.
Ephemeral data value passed through the Jidoka turn workflow.
Pure transition result for turn state changes.
Token and cost usage helpers for Jidoka turns.
Deterministic workflow contract and DSL for Jidoka.
Runs durable declarative workflows in the background.
Executes one explicit bounded workflow loop.
Serializable continuation data for a suspended bounded loop.
Inspectable data for one bounded loop iteration.
Final value and inspectable history from a bounded workflow loop.
Sandboxed Lua authoring layer for dynamic Jidoka workflow plans.
Reference helpers for declarative Jidoka.Workflow data wiring.
Data contract for local workflow step retry policy.
Reconnectable public view of one background workflow run.
Safe lifecycle projection for one persisted background workflow event.
One-time or recurring background workflow schedule contract.
Inspectable evidence for one schedule trigger decision.
OTP scheduler that creates normal Jidoka.Workflow.Background runs.
Serializable state for one suspended declarative workflow.
Data contract for a deterministic Jidoka workflow.
Data contract for one deterministic workflow step.