Modules
Thin layer over Raxol.Core.Runtime.Application for building AI agents.
Behaviour for pluggable AI model integration.
Behaviour for reusable, composable agent operations.
Composes actions into sequential pipelines.
Lightweight schema validation for Action input/output.
Converts Action modules to LLM tool definitions and dispatches tool calls.
LLM-callable cross-session memory actions.
Delete a memory by its id.
Search cross-session memory for facts relevant to a query.
Persist a fact to cross-session memory.
Search past conversation history for raw messages relevant to a query.
LLM-callable procedural-memory (skill) actions.
List available skills (metadata only -- the cheap progressive-disclosure level).
Create, patch, or delete a managed skill.
Read a skill's SKILL.md body, or one supporting file within it.
Virtual filesystem actions for AI agents.
Pure ALLOW/ASK/DENY authorization reducer.
The folded outcome of one evaluate/5 pass.
Engine state: current labels, remembered approvals, monotonic spec.
Composes the ALLOW/ASK/DENY engine into the Raxol.Agent.CommandHook chain.
Label state for the authorization engine, with monotonic merge.
A single policy in the ALLOW/ASK/DENY authorization engine.
Per-workflow authorization engine as a GenServer.
The outcome a single authorization policy returns when it evaluates.
Per-task-kind model routing for background agent work.
AIBackend wrapping the Claude Code CLI as a native harness.
AIBackend wrapping the Cursor agent CLI (cursor-agent) as a native harness.
HTTP-based AI backend using Req.
Proton Lumo AI backend with U2L (User-to-LLM) encryption.
Cryptographic operations for Proton Lumo's U2L (User-to-LLM) encryption.
Deterministic AI backend for testing.
Generic Raxol.Agent.AIBackend runtime for native CLI harnesses.
Resolve a Raxol.Agent.ExecutorConfig to a concrete backend module + options.
Behaviour for Raxol.Agent.Policy.Cache storage.
ETS-backed Raxol.Agent.Cache adapter.
Postgrex-backed Raxol.Agent.Cache adapter.
Agent communication primitives.
Pre/post execution hooks for agent commands.
Token-aware message history compaction for agent sessions.
ETS-backed persistent context that survives agent restarts.
One immutable entry in a Raxol.Agent.Conversation.Log.
Append-only conversation item log with live-tail-no-replay streaming.
Records Raxol.Agent.Stream events into a Raxol.Agent.Conversation.Log.
Behaviour for Raxol.Agent.Conversation.Item persistence.
ETS-backed Raxol.Agent.Conversation.Store adapter.
Keeps agent-authored skills healthy: ages unused ones and bounds their growth.
Agent-specific effect directives.
Spawn a task with a sender callback. The function receives a sender/1
closure that can be invoked multiple times to send messages back to the
TEA loop as {:command_result, msg}.
Route a message to another agent by id. The target is looked up in
Raxol.Agent.Registry; on success the message arrives as
{:send_message, message} via GenServer.cast/2; on failure the
sender receives {:command_result, {:send_agent_error, :not_found, target_id}}.
Run a shell command via Port. Returns a single
{:command_result, {:shell_result, %{exit_status: status, output: binary}}}
message when the command completes or the timeout elapses.
Forwarding helpers for Raxol.Agent.Stream events.
Explicit {harness, model, auth} configuration for an agent executor.
Native harness driver for the Claude Code CLI (claude).
Native harness driver for the Cursor agent CLI (cursor-agent).
Builds the MCP configuration that injects Raxol's tools into a native CLI.
Parser for the --output-format stream-json NDJSON protocol shared by Claude
Code and Cursor's cursor-agent.
LSP context enrichment for agent prompts.
MCP client for consuming external tool servers.
JSON-RPC 2.0 message encoding/decoding for MCP.
Cross-session memory for Raxol agents.
Pure helpers that weave a memory provider into an agent turn.
A single cross-session memory entry.
Full-text recall over raw conversation history.
A Raxol.Agent.Memory provider that composes several providers into one.
Default cross-session memory provider: a self-contained ETS+DETS store.
Behaviour for a native CLI harness: an external coding-agent CLI (Claude Code, Cursor, ...) that owns its own agent loop and tool dispatch.
Coordinates multiple AI agents in the cockpit.
Runtime permission enforcement for agent commands.
Umbrella for declarative Raxol.Agent.PolicyApplier policies.
Cache policy: short-circuit an operation when its :key_fn
matches a cached value in the configured Raxol.Agent.Cache
adapter.
Retry policy: wrap an operation in a bounded-attempt loop with configurable backoff and error-matching.
Timeout policy: abort an operation after :wall_ms elapsed
wall-clock time.
Runtime that wraps an operation in a list of
Raxol.Agent.Policy structs.
GenServer running the observe-think-act loop for an AI agent.
Behaviour for agents running in the observe/think/act loop (Agent.Process).
Message format for agent-to-agent and pilot-to-agent communication.
Multi-dimensional isolation protocol for agent operations.
Async-task isolation dimension for Raxol.Agent.Sandbox.
Walk a list of sandboxes for a single authorization decision.
Inter-agent messaging isolation dimension for
Raxol.Agent.Sandbox.
Shell isolation dimension for Raxol.Agent.Sandbox.
Raxol.Agent.CommandHook implementation that consults an agent's
declared sandbox/0 list before allowing a directive to fire.
After-turn background curation: review a completed agent turn and persist durable knowledge without touching the live conversation.
Transforms a raw view tree into a semantic tree for agent consumption.
Manages a single agent's TEA application lifecycle.
HTTP/SSE server for remote agent session observation.
Real-time event streaming for agent sessions.
A procedural-memory skill: an agentskills.io SKILL.md parsed into a struct.
Entry points for the procedural-memory (skills) subsystem.
Disk-backed index of procedural-memory skills, with usage telemetry.
Behaviour for agent execution strategies.
Sequential action execution strategy.
ReAct (Reasoning + Acting) strategy.
Stream-first API for agent sessions.
Typed structs for Raxol.Agent.Stream events plus conversion helpers.
Final answer from the agent.
Error during stream execution.
Streaming text chunk from the LLM.
Result of executing a tool.
LLM is requesting a tool call.
End of one ReAct turn.
Supervision subtree for the agent subsystem.
Supervisor for agent teams.
One entry in a Raxol.Agent.ThreadLog.
Behaviour for Raxol.Agent.ThreadEvent persistence.
ETS-backed Raxol.Agent.ThreadLog adapter.
Postgrex-backed Raxol.Agent.ThreadLog adapter.
Telemetry handler that routes agent-side events
([:raxol, :agent, :policy, :*] and
[:raxol, :agent, :sandbox, :denied]) into a
Raxol.Agent.ThreadLog adapter as durable audit entries.
Composable authorizers for the LLM tool-call path.
One endpoint of the reverse co-driving tunnel.
Wire frame for the reverse co-driving tunnel.
In-process link between two Raxol.Agent.Tunnel endpoints.
Drives one self-improving agent turn for an agent module.
Convenience macro for agents running in the observe/think/act loop.
A derived, per-user model of who the agent is talking to.
AI agent framework for Elixir built on OTP.