vllm-project/vllm · warning · Error

utility call `{method}` returned inconsistent results across

Error message

utility call `{method}` returned inconsistent results across engines: {values}

What it means

EngineCoreError::InconsistentUtilityResults is returned when a utility call is fanned out to multiple engines (e.g. data-parallel ranks) and they do not all return the same value, with `values` showing the per-engine results. The client refuses to pick one arbitrarily because utility results are expected to be identical across replicas.

Source

Thrown at rust/src/engine-core-client/src/error.rs:98

    #[error("engine-core client is closed: {message}")]
    ClientClosed { message: String },
    #[error("request output stream for `{request_id}` closed unexpectedly")]
    RequestStreamClosed { request_id: String },
    #[error("utility call `{method}` failed (call_id={call_id}): {message}")]
    UtilityCallFailed {
        method: String,
        call_id: UtilityCallId,
        message: String,
    },
    #[error("utility call `{method}` returned an invalid result (call_id={call_id}): {message}")]
    UtilityResultDecode {
        method: String,
        call_id: UtilityCallId,
        message: String,
    },
    #[error("utility call `{method}` closed unexpectedly (call_id={call_id})")]
    UtilityCallClosed { method: String, call_id: u64 },
    #[error("utility call `{method}` returned inconsistent results across engines: {values}")]
    InconsistentUtilityResults { method: String, values: String },

    /// A special variant to allow cloning the same error.
    #[error(transparent)]
    Shared(Arc<Self>),
}

View on GitHub (pinned to c794754062)

Solutions

Inspect the `values` string to see which engine(s) diverge and in what way
Wait until all engines/ranks are fully initialized before issuing the utility call
Use a per-engine utility interface instead of the uniform one for engine-local stats

Defensive patterns

Strategy: fallback

Validate before calling

// Wait until every DP rank reports ready before uniform utility calls
while !all_engines_initialized(&client).await { tokio::time::sleep(Duration::from_millis(100)).await; }
client.utility_call(method, payload).await

Type guard

pub fn is_inconsistent_utility(e: &vllm_engine_core_client::Error) -> bool {
    matches!(e, vllm_engine_core_client::Error::InconsistentUtilityResults { .. })
}

Try / catch

match client.utility_call(method, payload).await {
    Err(e @ vllm_engine_core_client::Error::InconsistentUtilityResults { values, .. }) => {
        tracing::warn!("engines diverged ({values}); falling back to rank 0 query");
        client.utility_call_on_rank(0, method, payload).await
    }
    other => other,
}

Prevention

Query per-engine stats through per-rank APIs instead of uniform ones
Ensure all ranks finish initialization before uniform queries
Log the values string to identify which engine diverges and why

When it happens

Trigger: Running a utility call in a multi-engine (data-parallel) setup where per-engine state genuinely differs: engine-specific metrics, uninitialized engines, or one engine returning an error placeholder while others return values.

Common situations: Polling a stat that is inherently per-engine (cache usage, queue depth) through an API that expects uniformity; engines at different initialization stages; version skew making one engine serialize the value differently.

Related errors

AI-assisted analysis of vllm-project/vllm@c794754062 (2026-08-14). Data as JSON: /api/errors/d519d4d9b3365eec. Report an issue: GitHub.