Struct AgentLoop 

pub struct AgentLoop {

    pub conversation: Conversation,
    pub tool_registry: Arc<ToolRegistry>,
    pub turn_runner: TurnRunner,
    pub permission_store: Arc<RwLock<PermissionStore>>,
    pub config: Config,
    pub ctx: Arc<dyn CtxBuilder>,
    pub env_snapshot: EnvSnapshot,
    pub phase: AgentPhase,
    pub turn_tokens: usize,
    pub total_tokens: usize,
    pub turn_start: Option<Instant>,
    pub last_checkpoint: Option<String>,
    pub plan_mode: bool,
    /* private fields */
}

The agent loop state.

Fields

conversation: Conversation

tool_registry: Arc<ToolRegistry>

turn_runner: TurnRunner

TurnRunner owns the provider, tools, and context.

permission_store: Arc<RwLock<PermissionStore>>

config: Config

ctx: Arc<dyn CtxBuilder>

Context construction strategy for the active provider. Selected at construction via ctx::for_provider and rebuilt on AgentCommand::ReloadConfig when the provider changes.

Arc (not Box) — shared with turn_runner.ctx so datalog’s build_messages call and runner’s actual send go through the same instance. Rebuilds on ReloadConfig update both clones (see the reload handler below).

env_snapshot: EnvSnapshot

Session-start environment snapshot — git branch / HEAD / status. Captured once in new(), refreshed on ChangeDir (new working tree ⇒ new repo). Stale-by-design: rendered with a disclaimer in build_system_prompt so the model knows it’s not live. See crate::ctx::env.

phase: AgentPhase

turn_tokens: usize

total_tokens: usize

turn_start: Option<Instant>

last_checkpoint: Option<String>

Last git checkpoint ref (SHA) for /undo rollback.

plan_mode: bool

Plan mode: restrict to read-only tools and inject planning instructions. Toggled via /plan command or SetPlanMode agent command.

Implementations

impl AgentLoop

pub fn new( config: Config, provider: Box<dyn LlmProvider>, tool_registry: ToolRegistry, tool_context: ToolContext, conversation: Conversation, ) -> (Self, AgentHandle)

Create a new agent loop and its corresponding UI handle.

pub fn new_with_shared_parts( config: Config, provider: Box<dyn LlmProvider>, shared_tools: Arc<ToolRegistry>, skill_registry: Arc<RwLock<SkillRegistry>>, runtime_label: Option<String>, tool_context: ToolContext, conversation: Conversation, ) -> (Self, AgentHandle)

Create a new runtime using the already-shared tool and skill registries. This path intentionally does not reload skills or register use_skill / graph tools; the initial runtime owns that one-time setup.

pub fn set_max_turns(&mut self, max: Option<usize>)

Set an optional hard cap on the number of LLM turns this agent will run. When the cap is reached, run_turn_loop exits via finish_turn(TurnStopReason::TurnLimit). None (the default) is unbounded. Used by the CLI --max-turns flag.

pub async fn run(self)

Run the agent loop. This is the main entry point — call from a tokio task. The loop processes commands from the UI and emits events back.