Struct AgentLoop 

pub struct AgentLoop<P: Platform> { /* private fields */ }

The core agent loop that processes inbound messages.

Consumes messages from the bus, invokes the LLM pipeline, executes tool calls, and dispatches responses. This struct holds all the dependencies needed for the full processing cycle.

Processing flow

1. Consume: Pull the next InboundMessage from the MessageBus.
2. Session: Look up or create a Session keyed by channel:chat_id.
3. Context: Build the LLM message list via ContextBuilder::build_messages.
4. Pipeline: Run the assembled context through the 6-stage pipeline (Classifier -> Router -> Assembler -> Transport -> Scorer -> Learner).
5. Tools: If the LLM response contains tool calls, execute them via the ToolRegistry, append results, and loop back to step 4 (up to max_tool_iterations).
6. Respond: Extract the final text response and dispatch an OutboundMessage to the bus.
7. Persist: Save the updated session and append to history.

Implementations

impl<P: Platform> AgentLoop<P>

pub fn new( config: AgentsConfig, platform: Arc<P>, bus: Arc<MessageBus>, pipeline: PipelineRegistry, tools: Arc<ToolRegistry>, context: ContextBuilder<P>, sessions: Arc<SessionManager<P>>, permission_resolver: PermissionResolver, ) -> Self

Create a new agent loop with all dependencies wired.

Arguments

• config – Agent configuration (model, max_tokens, etc.)
• platform – Platform abstraction for filesystem/env/http
• bus – Message bus for consuming inbound and dispatching outbound
• pipeline – Pipeline registry for LLM invocation
• tools – Tool registry for executing tool calls
• context – Context builder for assembling prompts
• sessions – Session manager for conversation persistence

pub fn with_cancel(self, token: CancellationToken) -> Self

Attach a CancellationToken so the agent loop exits promptly on shutdown instead of waiting for all bus senders to be dropped.

pub fn with_auto_delegation(self, delegation: Arc<dyn AutoDelegation>) -> Self

Attach an auto-delegation router for pre-LLM routing.

When set, messages matching delegation rules are routed to the delegate_task tool before the local LLM processes them.

pub fn config(&self) -> &AgentsConfig

Get a reference to the agent configuration.

pub fn platform(&self) -> &Arc<P>

Get a reference to the platform.

pub fn bus(&self) -> &Arc<MessageBus>

Get a reference to the message bus.

pub async fn run(&self) -> Result<()>

Run the agent loop, consuming messages until the bus is closed or the optional CancellationToken is triggered.

This is the main entrypoint. It pulls messages from the inbound channel and processes each one through the full pipeline. Errors on individual messages are logged but do not terminate the loop.