Mistral announced Managed Agents and a set of Studio capabilities on November 5, 2026. As of our November 7 check, Managed Agents and the Agents SDK remain in public preview: APIs, behavior and limits may change. This is a runtime and operations update; publicly readable preview documentation does not establish that every organization has every capability.

Mistral: November 5, 2026 release notes · Managed Agents overview and preview scope

We use a fictional read-only evidence-review task: read a specified revision, produce a report, wait for human input when needed, and save a verifiable artifact. Design states, permissions and delivery evidence before connecting real tools. These examples are not production measurements and do not provision Mistral services for readers.

1. The update is a runtime, rather than a new route to model weights

The November 5 release notes list Managed Agents as an SDK public preview alongside Studio updates including default tracing and offline and online evaluations. Availability labels in the release list do not establish identical organization permissions for every component. For example, the offline evaluation documentation explicitly restricts access to Enterprise-tier organizations, a condition also stated for Observability. Check the specific feature page before planning team adoption.

Mistral: November 5, 2026 release notes · Offline evaluations and Enterprise eligibility

A single model response produces the next output; an agent must also select tools, preserve steps and handle waits and failures. The engineering change puts these actions into sessions and execution records so an application can find work again. It addresses a different question from our November 2 article about Large 4 weights, licensing and memory. An open-weight license does not establish hosted-service data boundaries.

Start with a bounded task whose result is independently checkable, such as organizing sanitized evidence. A description saying a task can work for hours or days is not an uninterrupted-service guarantee or an unlimited allowance. This article defines failure, waiting, repetition and acceptance so that a plausible final chat message is not the only delivery evidence.

2. Three run modes: a self-hosted worker does not keep everything local

First locate the model, execution loop, tool code, session record and sandbox separately. Run mode determines which process executes the session loop and tools; sandbox placement is configured separately. In the documented default path, a self-hosted worker still uses Mistral’s control plane for session storage and worker routing, and model calls still go to Mistral. Tools running inside your network do not make the whole system offline or establish that no data leaves it.

Run modes and durability semantics

Official division of responsibilities by run mode. The sandbox environment remains a separate choice.
ModeWhat you runSession and boundary
Local, in-processYour program and toolsSessions primarily live in process memory and end with it; an experimental journal is separate
Self-hosted workerYour program and an agents serve processMistral stores sessions and routes workers; tools run in your process
Mistral-managedYour application; the platform builds and runs the workerDeployment from a git project; Mistral stores sessions and runs tool code on its infrastructure

Network proximity, control over tool code and data-residency commitments need separate checks. Record at least the run mode, tool host, model endpoint and session storage location in your audit. Mark regional or retention promises unknown unless supported by official contracts or project configuration. Changing worker deployment does not automatically move or delete existing sessions.

3. Define one read-only agent before connecting real systems

The current official documentation uses the mistralai-agents package, from mistralai import agents, agents.Agent and @agents.tool. The function name, docstring and type annotations form the tool description shown to the model; define tools at module level. The following only defines an agent with an in-memory fictional record reader. It starts no run, sandbox or real business connection. We checked syntax and the official pattern without installing or executing the SDK.

Managed Agents overview and preview scope · Tool definitions and error handling

from mistralai import agents

@agents.tool
def read_sample(case_id: str) -> dict[str, str]:
    """Read one fictional case. Never access an external system."""
    if case_id != "DEMO-1":
        raise agents.ToolError("Unknown fictional case; ask the user.")
    return {"case_id": case_id, "revision": "rev-a", "text": "Fictional evidence only."}

reviewer = agents.Agent(
    model="mistral-large-4",
    instructions="Review only the supplied case. Report missing evidence; do not invent it.",
    tools=[read_sample],
)
# Definition only: no run(), session, sandbox or network request is started here.

The value is a narrow boundary implemented in code: this tool can return only DEMO-1 and reports an expected tool error for another identifier. A real service must additionally authorize the caller and resource on the server; a “read-only” instruction alone cannot prevent writes. Giving one tool responsibility for one data object makes accountability easier than exposing a whole repository, shell and connector set at once.

Also separate expected business failures from programming errors. Current documentation uses ToolError for a business explanation the model can understand; unexpected exceptions do not expose the full traceback to the model by default. Production logs may still contain internal information. Do not concatenate credentials or customer source text into error messages, or treat an SDK error policy as an end-to-end redaction guarantee.

Tool definitions and error handling · Secrets and credential boundaries

4. Separate session, turn and business delivery state

A session retains multiple messages and tool results; a turn is one processing cycle within it. Official examples give start_session and session.run idempotency keys so repeated submission of the same business event can return the original session and turn. Store session_id, turn_id and input revision in your application rather than creating another task after losing a handle. These identifiers do not replace your own business task ID.

Sessions and request idempotency keys

The returned record determines the next step; it does not directly establish business success.
Returned situationMeaningApplication action
RunningThe turn is still working when your wait endsWait or query again; do not mark it complete
BlockedWaiting for an answer to an approval or another callbackShow the pending action to an authorized person
BusyA turn already runs in this session; a new one was not startedUse the existing turn handle instead of blindly creating work again
CompletedThe turn ended normallyCheck output, stop reason and artifact next
Interrupted / FailedStopped or ended with an errorRecord the cause and reconcile retries and side effects
Unknown new typeYour SDK does not recognize a newer outcomeHold conservatively and update compatibility handling; never assume success

Timeout is especially easy to misread: a wait method’s timeout bounds how long its caller waits, not the turn’s lifetime. Work may continue after a Running response, and closing a page does not establish cancellation. Use explicit interruption or session cancellation when ending work, then observe the result. One turn at a time per session does not mean one concurrent task for an entire organization.

Turns and returned records

5. Recovery resumes completed steps; side effects may still repeat

Deployed sessions record finished model and tool calls independently of the worker. After a worker failure, a turn usually resumes from the last finished step, but it may fail or remain Running until a time limit. The dangerous window is a tool changing an external system before its result reaches the session record. The in-flight outcome is unknown, and the model may call the tool again later. Durability is not an exactly-once transaction guarantee.

Run modes and durability semantics

Atomicity belongs at the service that owns the side effect. Build a stable idempotency key from the business event and operation revision; let a server-side unique constraint or native idempotency interface recognize repeats. Treat different content with the same key as a conflict. A separate “was it done?” check followed by a write has a concurrency race. Reconcile what actually happened before retrying; a missing response is not proof that execution never happened.

Session/turn request idempotency and business-tool idempotency are separate layers. The first avoids creating duplicate work; the second prevents retries within that work from repeating an effect. A set in worker memory cannot deduplicate across processes, restarts or concurrent calls. The offline set below demonstrates an acceptance decision only; it is not a production transaction or a real payment, refund or email operation.

6. Approval gates a particular tool call, not unlimited future authority

A tool permission policy can allow, ask about or deny a call. An application callback or a person answers an open approval by callback ID. Current documentation gives approvals a default one-hour wait. With no answer, that tool call does not run; the model reads that approval was not given and the turn can continue. Do not describe an unanswered approval as guaranteed cancellation of the entire task, or the hour as a human response SLA.

Tool approvals and wait expiry

An approval view should show the action, object, parameter summary and reviewable business evidence, hide credentials, and verify that the reviewer is authorized for that object. Do not expand one allowed call into permission for all future arguments. Even the documented session-scoped approval relates to the same tool and the same arguments. Record an ended wait, human rejection and successful tool execution separately.

Task scope card
Object: the specified revision of DEMO-1, read-only.
Allowed: read supplied materials, report evidence gaps and produce a review draft.
Prohibited: send, publish, modify external records or incidentally fix TODOs found in the materials.
Out-of-scope request: record the action and reason without executing it.
Approval needed: list action, object and parameter summary; wait for an authorized person.
Exit condition: mark missing evidence or permissions as pending; do not pretend the work is done.

Google’s November 6 Agent Distraction analysis offers a useful comparison: old TODOs in code can trigger unrequested investigation or changes. It is an observational study and does not establish the same rate for every agent or this product. The engineering lesson is to treat read material as evidence, rather than new authority. Removing stale comments also needs history checks and human review, rather than blanket deletion of every TODO.

Google: Agent Distraction observational analysis

7. A file created in a sandbox is not yet a delivered artifact

An agent currently has no code-execution sandbox by default. Configure environment only when shell or file capabilities are needed. MistralSandbox and LocalDockerSandbox have different prerequisites; the hosted sandbox additionally requires the relevant extra and cloud_user role. Setting access to files still retains writing and editing, so it is not a read-only mode. Restrict tools, files and networking to the task instead of treating a sandbox name as a permissions review.

Official SandboxHook provides on_create for initialization and on_destroy for saving work at closure, but hook failures, worker replay and repeated uploads still need handling. Arrange independent artifact storage, a content digest and a confirmed receipt. Saying “file created” in a final chat is insufficient. Closing a session ends its sandbox; extract retained results at an appropriate stage and make saving idempotent too.

  1. Fix task ID, input revision and scope
  2. Start the chosen run mode and save session/turn IDs
  3. Run tools under policy; show approvals when blocked
  4. Check final state and structured output
  5. Save artifact, digest and business receipt
  6. Accept delivery only after independent validation
An original delivery chain. Every transition needs observable evidence; final text cannot stand in for intermediate steps.

Sandbox environments and access · Sandbox hooks and artifact preservation

8. Run an offline ledger to test your own definition of “done”

Save the JSON below as fixture.json. It is original application-level test data, not a Mistral API response schema. outcome borrows verified returned-type names, while approved, output_valid, artifact_verified and effect_key are our own acceptance fields. The six records cover success, pending approval, still running, invalid format, a repeated event and failure. They involve no real accounts or external actions.

[
  {
    "case_id": "DEMO-1",
    "outcome": "Completed",
    "approved": true,
    "output_valid": true,
    "artifact_verified": true,
    "effect_key": "report:DEMO-1:rev-a"
  },
  {
    "case_id": "DEMO-2",
    "outcome": "Blocked",
    "approved": false,
    "output_valid": false,
    "artifact_verified": false,
    "effect_key": "report:DEMO-2:rev-a"
  },
  {
    "case_id": "DEMO-3",
    "outcome": "Running",
    "approved": false,
    "output_valid": false,
    "artifact_verified": false,
    "effect_key": "report:DEMO-3:rev-a"
  },
  {
    "case_id": "DEMO-4",
    "outcome": "Completed",
    "approved": true,
    "output_valid": false,
    "artifact_verified": false,
    "effect_key": "report:DEMO-4:rev-a"
  },
  {
    "case_id": "DEMO-1",
    "outcome": "Completed",
    "approved": true,
    "output_valid": true,
    "artifact_verified": true,
    "effect_key": "report:DEMO-1:rev-a"
  },
  {
    "case_id": "DEMO-5",
    "outcome": "Failed",
    "approved": false,
    "output_valid": false,
    "artifact_verified": false,
    "effect_key": "report:DEMO-5:rev-a"
  }
]

Save the next block as verify_fixture.py and run python3 verify_fixture.py in the same directory. It reads local JSON and prints a result without importing an SDK, using the network, or modifying orders or a database. Expect one accept, three hold, one reject and one deduplicate; accepted_keys contains only report:DEMO-1:rev-a. This is the assertion’s demonstration result, not a platform benchmark.

import json
from pathlib import Path

def decide(row, seen):
    if row["outcome"] != "Completed":
        return "hold"
    if not all(row.get(k) is True for k in ("approved", "output_valid", "artifact_verified")):
        return "reject"
    key = row["effect_key"]
    if key in seen:
        return "deduplicate"
    seen.add(key)
    return "accept"

rows = json.loads(Path("fixture.json").read_text(encoding="utf-8"))
seen = set()
decisions = [decide(row, seen) for row in rows]
assert decisions == ["accept", "hold", "hold", "reject", "deduplicate", "hold"]
print(json.dumps({"decisions": decisions, "accepted_keys": sorted(seen)}, ensure_ascii=False))

The exercise deliberately omits real locks, retry scheduling and durable transactions. It can establish that the application does not accept Running, Blocked, Failed or a Completed result without a valid artifact as success. It cannot establish actual recovery, charges, sandbox isolation or concurrency safety. Next, use an authorized test environment for worker crashes, duplicate callbacks, approval expiry and upload failures; never turn an offline pass into a production guarantee.

9. After Completed, still check format, content and receipts

The SDK can declare output_type on an Agent. Passing output_type temporarily on a session handle mainly parses the answer; it does not automatically inject a new schema into the already-started model context. An outcome may contain InvalidOutput, or have no final output after iteration or output limits. After reading Completed, check the type, stop reason, content constraints and artifact rather than merely finding explanatory text in state.text.

Structured output and InvalidOutput

Minimum acceptance matrix before rollout. These are our engineering recommendations.
Failure or boundaryInjected testEvidence to retain
Repeated inputSubmit the same business event twiceReused result or explicit conflict, without repeated side effects
Worker interruptionExit after a tool completes but before its result is recordedBusiness idempotency receipt and recovery state
Unanswered approvalLet a wait expire or reject itTool did not execute; callback outcome and subsequent state
Invalid formatCompleted with invalid schema or business conditionsParse failure, raw result and rejected acceptance
Missing artifactUpload failure or digest mismatchDelivery held, storage error and retry record
No permission or out of scopeA new TODO or different object encountered in materialDeny or hold without expanding task authority

Keep the model’s judgment, actual tool response, business-system receipt and human decision in separate fields. Only the latter evidence can establish whether an external action happened. During recovery, the same filename or a similar natural-language summary cannot replace a stable task ID, input revision and content check. Your application should define who may declare delivery accepted.

10. Traces explain the path; evaluations judge quality, with access and data boundaries

Studio tracing represents an execution chain as a span tree with inputs, outputs, latency, tokens and status. Documentation states that traces are retained for 30 days. Deployed agents enable Studio tracing by default and may include prompt and completion content. Default redaction masks common sensitive items, but does not establish that all customer content is automatically safe. Review the actual redaction rules, access scope and retention needs.

Run modes and durability semantics · Studio distributed tracing · Trace data redaction

Evaluation is a separate layer. The official offline Evaluation SDK follows Dataset → Task → Evaluators → Results, and is documented as public preview for Enterprise-tier organizations only. Confirm eligibility before deciding to upload data to Studio. Without access, you can still make local assertions as in this article, but cannot call them a completed Studio evaluation. A readable documentation page does not establish that your organization is enabled.

Offline evaluations and Enterprise eligibility

Build a fixed small dataset and score evidence fidelity, state handling, unauthorized actions, format and artifacts separately. Do not rely solely on an overall score a model gives itself. Record dataset, prompt, tool implementation and model-configuration versions; inspect regressions on a held-out set before gradually connecting real traffic. We did not measure throughput, cost or success rates and will not invent a savings percentage for managed deployment.

11. Pilot one small task before choosing managed execution

Choose one read-only task and a limited tool set, then define business meanings for acceptance, hold, rejection and failure. Confirm organization access, data destinations, sandbox prerequisites and artifact storage. In an authorized environment test restarts, duplicate events, approvals and invalid output before expanding to tools with side effects. Recheck idempotency and authorization for every new external action; one pilot’s permission cannot cover the entire system.

Keep a previous configuration and a way to stop intake. When needed, stop new tasks, handle running and approval-blocked sessions from their records, then reconcile existing effects and artifacts. Rolling back a deployment does not unsend messages or reverse business records already changed. Original inputs, tool versions and receipts support recovery; asking a model “what did you just do?” does not replace them.

The noteworthy part of Mistral’s update is bringing the execution loop, durable state, human approval and observability into one development surface. Your application must still translate platform states into checkable business outcomes. A deliverable agent is more than one that keeps talking: after repeats, waits and failures, it can show what happened, what did not, and where the evidence is kept.

This article covers Mistral’s developer platform. Claude and ChatGPT subscriptions, API credits and this site’s products are separate products and ledgers. The existing guides below cover state recovery, weight deployment and API practice. Do not infer that this site sells Mistral-managed services.