Resume sessions

Asks a paused session to continue, on the same terms as a pause.

POST /v1/agent/sessions/{id}/resume

Agent → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/agent/sessions/{id}/resume`
Method	`POST`
Operation	`post_agent_sessions_by_id_resume`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Asks a paused session to continue, on the same terms as a pause.

A chat turn that was paused or STOPPED runs again: the same session, in the same sandbox with every file it had written, told message next ("Continue where you left off." when there is none). Only the person whose turn it was may resume it, since the agent runs as them.

Request

4 fields, body application/json (required).

Field	In	Type	Required	Description
`id`	path	string	yes	ID is the session to steer, from the path.
`id`	body	string	—	ID is the session to steer, from the path.
`message`	body	string	—	Message is free text for the running agent, up to 16 KiB.
`payload`	body	any	—	Payload is a structured argument for the command: any valid JSON up to 64 KiB, scanned for credentials before it is stored (a hit refuses the command with 422 and the findings).

Response

Status	Body	Meaning
`200`	agent.controlResult	ok
`default`	problem-details	refused

200 body — 11 fields.

Field	In	Type	Always	Description
`command`	body	string	—	Command is the verb that was recorded: pause, resume, stop or message.
`event`	body	agent.eventView	—
`event.actor`	body	string	—	Actor is who produced the turn.
`event.createdAt`	body	string	—	CreatedAt is when the turn was recorded, RFC 3339 in UTC to the second.
`event.id`	body	string	—	ID is the event's own handle, minted as "evt_" + 32 hex characters.
`event.kind`	body	string	—	Kind is what the turn IS, from a closed six: message (a model turn), tool-call, spawn (a subagent started), log, status, control (a steering command the running surface consumes).
`event.payload`	body	any	—	Payload is the turn's body, embedded as JSON rather than as a string — whatever the writer sent, up to 64 KiB, checked for well-formedness and scanned for credentials before it was stored.
`event.seq`	body	integer (int64)	—	Seq is the turn's position in this session's log: monotonic from 1, assigned by the store inside the insert, and unique PER SESSION rather than globally.
`event.sessionId`	body	string	—	SessionID is the session this turn belongs to.
`forwarded`	body	boolean	—	Forwarded is whether the command also reached the durable-execution engine.
`run`	body	string	—	Run is the run a resume started, under the same session.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo agent sessions resume <id>

.ts

.py

.go

.rs

.java

import { Configuration, AgentApi } from 'hanzoai';

const api = new AgentApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.postAgentSessionsByIdResume({ id: 'id', id: "<id>", message: "<message>" });

from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import AgentApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = AgentApi(client).post_agent_sessions_by_id_resume(id='id', id="<id>", message="<message>")

cfg := hanzoai.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := hanzoai.NewAPIClient(cfg)

resp, _, err := client.AgentAPI.PostAgentSessionsByIdResume(context.Background()).Execute()
if err != nil {
	return err
}

use hanzo_client::apis::{configuration::Configuration, agent_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = agent_api::post_agent_sessions_by_id_resume(&cfg, Default::default()).await?;

import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.AgentApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new AgentApi(client).postAgentSessionsByIdResume();

curl -X POST https://api.hanzo.ai/v1/agent/sessions/<id>/resume \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "id": "<id>",
       "message": "<message>"
     }'

MCP reaches agent through the agent tool, which names its 38 operations with its own verbs — this one among them, under a name only MCP declares. describe explains any of them:

curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "describe",
         "arguments": {
           "op": "list_agents"
         }
       }
     }'

Agent API · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousCreate pause NextStop sessions