Steering and queueing

In a typical Laravel application flow, you rarely need steering directly. Laravel’s synchronous execution pattern benefits little from it, and the default queueing behavior is usually the right choice.

There are two patterns for sending messages while the agent is processing: steering and queueing.

Overview

send(), sendAndWait(), sendAndStream(), and Copilot::run() all accept a $mode parameter.

Mode	Behavior
`"enqueue"` (default)	Processed as a queue after the current turn completes
`"immediate"` (steering)	Injected immediately into the currently processing turn

Steering (`"immediate"`)

Inject a message directly into the turn the agent is processing. The agent receives the message in real time and adjusts its response. Use it when you want to redirect ongoing work without interrupting it.

use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Contracts\CopilotSession;

Copilot::start(function (CopilotSession $session) {
    // Start a long-running task
    $messageId = $session->send(prompt: 'Refactor the authentication module to use sessions');

    // Redirect while the agent is still processing
    $session->send(
        prompt: 'Actually, use JWT tokens instead of sessions',
        mode: 'immediate',
    );

    // Wait until the agent goes idle
    $response = $session->sendAndWait(prompt: 'Summarize what you did');
});

Steering is best-effort. If the agent has already committed to a tool call, it’s applied after that tool call finishes but still within the same turn. If the steering message arrives after the turn is complete, it’s automatically moved into the queue.

Queueing (`"enqueue"`)

Add the message to a queue and process it after the current turn completes. Each queued message runs as its own turn. This is the default when $mode is omitted.

Copilot::start(function (CopilotSession $session) {
    // Start the first task
    $session->send(prompt: 'Set up the project structure');

    // Queue follow-up tasks while the agent is still processing
    $session->send(prompt: 'Add unit tests for the auth module', mode: 'enqueue');
    $session->send(prompt: 'Update the README with setup instructions', mode: 'enqueue');

    // Wait until the queue is empty
});

The practical Laravel view

In Laravel, the primary pattern is the synchronous one using Copilot::run() or sendAndWait(). Both send a message and then wait until the agent goes idle, meaning there’s no opportunity to inject anything while the agent is processing, so $mode doesn’t really matter.

// Copilot::run() calls sendAndWait() internally,
// so specifying mode has no effect.

$response = Copilot::run(prompt: 'Tell me something about Laravel.');

// Within a session, calling sendAndWait() in sequence also doesn't need it.
Copilot::start(function (CopilotSession $session) {
    $r1 = $session->sendAndWait(prompt: 'First task');
    $r2 = $session->sendAndWait(prompt: 'Second task');
});

Steering ("immediate") shines when you’re sending messages asynchronously with send() while another concurrent message intervenes in an in-flight turn. Given Laravel’s synchronous flow, that opportunity is hard to create, so the default (no $mode) is almost always the right choice.

Which should you use?

Situation	Pattern
The agent is heading in the wrong direction	Steering (`"immediate"`)
You just thought of the next thing to do	Queueing (`"enqueue"`)
You want to run multiple tasks in order	Queueing (`"enqueue"`)
A regular Laravel app	Default (`$mode` not needed)

Best practices

Default to queueing — Omitting $mode (or explicitly setting "enqueue") is right for most cases. The behavior is predictable.
Steer for corrections — Use "immediate" only when the agent is clearly doing the wrong thing.
Keep steering messages short — Use brief messages that make sense in the current context. Long, complex steering messages tend to cause more confusion than they solve.
Avoid rapid successive steering — Sending several steering messages in a short window may degrade the turn’s quality. When a major course change is needed, it may be more appropriate to interrupt the turn and start over.

References

For the latest updates, see the GitHub repository.

GitHub Copilot

SDK

AI SDK

VOICEVOX

Starter Kits

Feeds and RSS

Middleware

Steering and queueing