RubyLLM 2.0: The Agentic Loop, Exposed

# What this change is

# The verbs you get

• ask: unchanged convenience that runs the full conversation to completion.
• ask_later: stage a user message without sending it.

• step: perform whichever move is next (run tools if any are unanswered, otherwise generate).
• complete?: check whether the conversation is settled (the model answered without calling a tool).

These verbs compose: ask is ask_later followed by complete (or repeated step calls). That decomposition is purposeful: it gives you hooks between model and tool rounds for batching, human approval, logging, or persistence.

# Why you'd use this

• Fine-grained control over iteration budgets and the number of model calls.
• Insert human review before tools run.
• Batch generation for many chats at once, then run tools locally between rounds.
• Persist conversation state and resume runs across processes or deploys.

# One move per job: reliable, resumable runs Because each verb reads and writes persisted messages, you can implement an agent as a chain of jobs where each job performs a single turn. Example pattern: schedule an AgentTurnJob that loads the chat, calls chat.step, and enqueues itself again unless chat.complete?. Benefits:

• Granular retries when a job fails.
• Workers are not monopolized by long runs.
• If a run dies mid-tool-round, run_tools skips tool calls that already have results so remaining tools complete on resume.

If you use Rails 8.1 ActiveJob Continuations, you can checkpoint after each move and survive redeploys without managing an external cursor.

# Cancellation and stopping

break if handed_off? # your own stop condition

If you instead want exactly one tool call per model response, use chat.with_tool_options(calls::one). For total budget control, count your step or generate calls in the loop you control.

# Practical patterns

• Resumable agent: persist messages, run one step per job, re-enqueue unless complete.
• Batching: schedule generate for many chats, then run_tools locally between rounds to keep external calls efficient.
• Human-in-the-loop: ask_later, show proposed tool calls to a reviewer, run_tools only after approval.

RubyLLM 2.0 turns the agentic loop into explicit, testable, and resumable Ruby code so you can integrate it into job queues, web controllers, and multi-process systems without hidden control flow.