What a Sume MCP create result tells the agent to call next
A Sume MCP create result carries agent.next_step: jobs_wait with the job_id and timeout 50, plus poll_after_seconds 5. Follow it; do not resubmit.

After a create call on Sume's hosted MCP, the result's agent object includes next_step: the tool jobs_wait with the job id and a timeout_seconds of 50, and poll_after_seconds, which defaults to 5. Follow it and do not resubmit the create.
The envelope fields
Successful tool results are merged with an agent envelope. It holds next_steps (plain sentences), next_step (one machine-readable call), adjustments, poll_after_seconds, recovery and hint. For tools whose name ends in _create, the sentences tell the agent to capture the request id and any resource id, then use jobs_wait, and not to echo prompts, signed URLs or private media URLs in reports.
| Field | Purpose |
|---|---|
| next_steps | plain-language follow-ups |
| next_step | one tool call with arguments, such as jobs_wait |
| adjustments | path, from, to and reason for any corrected input |
| poll_after_seconds | suggested spacing for status reads, default 5 |
| recovery | code and hint for a stop condition |
| hint | pointer when a field was redacted |
Job id discovery
The server finds the job id in several places, in order: a top-level job_id, then response.data.job_id, request_id, a nested job or run id, and finally a /v1/jobs/<id> status URL. You do not need to guess. If the envelope has no next_step, the call did not create a job, and you should read the result as it is.
Following it in code
The helper below prefers the server's pointer and falls back to the wait.
def follow(result: dict) -> dict:
step = (result.get('agent') or {}).get('next_step')
if step and step.get('tool') == 'jobs_wait':
return {'tool': 'jobs_wait', 'arguments': step['arguments']}
return {'tool': None, 'arguments': {}}
res = {'agent': {'next_step': {'tool': 'jobs_wait',
'arguments': {'job_id': 'job_1', 'timeout_seconds': 50}}}}
print(follow(res))Limits
The envelope is guidance for the next call, not a promise about timing. A render can outlast many slices. Keep re-issuing the wait, and read the jobs_wait post for slice rules.
What the envelope is for
A model reading a raw create response has to infer the follow-up call. The agent envelope states it: the tool, its arguments and a poll interval. That removes a class of mistakes, such as waiting on the wrong id, using a status poll in a tight loop, or giving up because the first read says in progress.
Checklist before you ship
- Copy job_id and timeout_seconds from next_step instead of retyping them.
- Treat poll_after_seconds as a floor for status polling, not as a deadline.
- Prefer jobs_wait over a hand-written polling loop.
- Never resubmit the create because the next step has not finished.
Sources
Related posts
More in Agents
- Agent says Sume MCP is down after one timeout: retry once, name it
One errored or timed-out Sume MCP call is just that call failing. Retry it once, report that tool's error, and never say the server is down.
- Sume MCP tool_name_typo: avatar_image_to_video_create is a typo
avatar_image_to_video_create gives tool_not_found; the real name is avatar-image-to-video_create. Sume sends did_you_mean and a tools_schema next_step.
- Sume MCP returned a tool descriptor, not a result: it did not run
If a Sume MCP call returns a tool name, description and schema instead of a result, the tool did not run. Re-call with the namespaced name your client lists.
- Sume schedule cron field: expr, IANA timezone and next_run_at
A Sume schedule's cron object holds expr, timezone and next_run_at, or null for an API-only schedule. How to read when the next run is due over the API.
Written by Sume