Accept a changeset in phase review_ready: the worker's changes become the Workspace's current files, saved as a new revision. expected_current_revision must be the changeset's comparison_current_revision, and the Workspace's current revision must still be that revision; otherwise the call is refused with 409 current_revision_conflict, and submit_workspace_changeset submits the worker again against the new current revision. A changeset that is still being compared or has conflicts is refused with 409 workspace_changeset_unresolved; a Workspace with an active run or file operation is refused with 409 workspace_changeset_busy. For conflicts (needs_resolution), use reject_workspace_changeset then create_workspace_worker with an adjusted task on the current files. To keep both versions, read the worker's file with read_workspace_file from incoming_revision, use send_workspace_message to ask the Workspace's agent to write the combined file into the Workspace, wait for that run to complete, then use reject_workspace_changeset on the conflicted changeset. The save completes after the call returns: poll get_workspace_changeset until state is accepted and result_revision is set. Repeating the call with the same arguments returns the same result.

Answer a question that a run is paused on, or deny an approval request. value answers a question; approved=false denies an approval request. approved=true is refused with 403 and the request's approve_url: only the account owner approves, in the Plori web app. Standing approvals (always_allow, scope) are refused from this connector. A question marked secret:true is refused here; the owner answers it in the Plori web app. After the paused run's files are saved, an answer continues the task in a new run, which keeps the paused run's approval rules: its outward actions still pause for the owner. The call waits up to 25 s for that run to start, and run_id in the result is that continuation run. When the result has continuation_pending: true instead, the answer is recorded and the run starts later without another call; get_run_result on the paused run then reports it as continuation_run_id.

Request cancellation of a run that has not ended. Returns status "cancelling" at once; the run then ends with status "cancelled", which get_run_result reports. A run that has already ended is refused with 409 run already finished.

Create a Workspace: durable files with saved revisions, a main conversation and run history. Unless default_manager_agent_id is given, the call also creates the Workspace's agent, which runs the messages sent to the Workspace; that agent counts against the account's agent limit, and the Workspace counts against its Workspace limit. default_manager_agent_id selects an existing agent instead. Every Workspace has an agent; an agent that receives no messages does no work and costs nothing. The call returns after the Workspace's first revision exists. No run starts. idempotency_key identifies the request for 24 hours: the same key with the same arguments returns the same Workspace, and the same key with different arguments is refused with 422 idempotency_key_reused. Names are not unique: a new key with a used name creates a second Workspace. Task messages, the files the agent reads, and the agent's work are sent through OpenRouter to these model providers: OpenAI, DeepSeek and Anthropic. All three supply the agent's models, with Anthropic for advisor reviews and OpenAI for result reviews. TypeSafe receives short typed-judgment requests about the agent's steps. Runs started through this connector do not generate video. The provider list follows Plori's model catalog and can change.

Use this when the user wants several independent tasks run at the same time, such as building or testing separate parts of a project or researching several topics in parallel. Do not use for a single task (send that with send_workspace_message) or for work you can finish in a few of your own tool calls. Start a worker: an agent that runs one task in a Workspace on its own copy of the Workspace files, so several workers can run at the same time without changing each other's files or the Workspace's current files. The call makes a copy of the Workspace's current revision for the worker, creates a task group unless task_group_id names an existing one, and queues the worker. It returns at once with worker_request_id, agent_id, working_copy_id and task_group_id; the worker starts when capacity allows. get_workspace_worker reports its run_id once it starts, save_state ready with saved_revision_id once its files are saved, and changeset_id and change_status. When the run completes normally and changes files, Plori submits the changes and accepts a clean comparison, so they become the Workspace's current files; otherwise submit_workspace_changeset submits the saved files. A worker started through this connector pauses before each action outside its own environment (connected-account and MCP writes, outbound HTTP writes, git push, publishing, deploys, email) until the account owner approves that one action at approve_url in the Plori web app; the calling model cannot approve. Unless executor_agent_id is given, the call creates a new agent for the worker; worker agents do not count against the account's agent limit. Runs are charged to the account's prepaid US-dollar balance. idempotency_key identifies the request for 24 hours: the same key with the same arguments returns the same worker; if the Workspace's current revision changed between two calls with the same key, the second call can be refused with 422 idempotency_key_reused, and a new key starts a new worker.

Permanently delete a Workspace: its files, revisions, copies and conversations. This cannot be undone. Returns the Workspace with state deleting; the deletion completes in the background, and a Workspace that is already deleted returns status 204.

Get the authenticated account's prepaid US-dollar balance (balance_usd formatted in dollars, balance in micro-US-dollars), plan, limits, and the plans and credit packs on offer. Runs are charged to this balance; a run that the balance cannot cover is refused with 402 when it starts. This tool only reads: the account owner buys credit or changes plan in the Plori web app (prices: https://plori.ai/pricing). It returns only the authenticated account's own balance, never the balance of an account that shares Workspaces with it.

Get a run's current state by run_id. Every result has the run's status, timing, and attributed credits (micro-US-dollars) and tokens. A run that is still going also has last_worklog (the agent's latest note), last_tool_step, last_activity_at, tool_progress when it is recorded, and poll_after_seconds. A completed run has text (the agent's reply), a url to its conversation in the Plori web app, and files: the files the reply linked, as absolute URLs readable with the same bearer token as this call. Those links read the run's copy while file_source.state is pending and the saved revision once it is ready; save_failure is present when the save failed, and then the files are not durable. When file_source.source is agent_current_files, the links read the agent's current files, which later runs can change. A failed or cancelled run has cause, retryable and an error object that states what happened and whether the run was charged. A run with status "awaiting_input" lists its approval requests and questions, each approval request with an approve_url. After a request is answered, input_status is answered and continuation_run_id names the run that continues the task; input_status cancelled or expired means this run will not continue. An interrupted run that the platform resumed has resume_run_id.

Get one changeset: its state and phase, the changed paths (at most 500) and conflicting paths once compared is true, comparison_current_revision for accept_workspace_changeset, and result_revision after an accepted changeset is saved. read_workspace_file reads the worker's version of a file from incoming_revision. No run starts and nothing changes.

Get the amount charged to the account's balance for the runs of a Workspace, or of one task group in it, in a time window: the total, how complete it is (coverage), and the charges that make it up per run. A token limit is not a cost. No run starts and nothing changes.

Get one worker's status: whether it has started (run_id), how its run ended (run_status), whether its files are saved (save_state ready with saved_revision_id) and whether its changes were submitted and accepted (changeset_id, change_status; Plori submits the saved files of a normally completed run itself). A completed run alone does not mean the files are saved or in the Workspace; check save_state and change_status. get_run_result with run_id and workspace_id reads the worker's reply and its approval requests. No run starts and nothing changes.

List the runs of a Workspace or an agent that are paused on an approval request or a question, with each request's run_id, tool_call_id and kind, and for an approval request its approve_url. Only the account owner approves, at that URL in the Plori web app. A request is not listed when a later run in the same conversation has completed.

List the runs of a Workspace or an agent, most recently started first, with each run's status, timing, attributed cost and session_id (its conversation). Returns 20 runs unless limit is given (at most 100). When more runs exist, the result has next_cursor; passing it as cursor returns the next page, and its absence means the list is complete. tool_progress is null for an ended run and for a run without recorded tool progress. input_expired:true marks a run paused on a question that a later completed run in the same conversation has superseded.

List the changesets of a Workspace, one page at a time, with each one's state, phase and number of changed paths. get_workspace_changeset returns the changed paths. No run starts and nothing changes.

List the workers started in a Workspace, oldest first, one page at a time, with each worker's status, run_id, save_state and saved_revision_id. task_group_id limits the list to one task group. No run starts and nothing changes.

List the Workspaces the authenticated account owns and those other accounts share with it, with each one's id, name, state, owning account (account: user_id and email), the caller's role there (owner, member or viewer), agent (default_agent_id), main conversation id (main_session_id), current revision and root copy id. state is active, adopting (its files are moving to new storage; runs are refused until it is active again), deleting or deleted. All Workspaces are returned in one response, without paging. No run starts and nothing changes. With workspace_id, the workspaces list contains only that Workspace, including storage_readiness (state, since, pending_reason, retryable) when its storage is still starting. The root copy exists only once storage_readiness.state is ready.

Read a file or list a directory in a saved revision of a Workspace: the Workspace's current_revision, a worker's saved_revision_id, or a changeset's base_revision, incoming_revision or result_revision. A file returns its UTF-8 text, up to 262144 bytes; a larger file is refused, and a binary file is refused with 415. A directory returns its entries one page at a time. No run starts and nothing changes.

Reject a changeset: the Workspace's files stay as they are, and the worker's copy and saved revision are kept. A rejected or accepted changeset cannot change again. Repeating the call returns the same result.

Use this when the user wants one task to start later, such as "run this tonight" or "check again in two hours". Do not use for a repeating schedule such as every day or every week: ask the Workspace's agent with send_workspace_message to set up a scheduled workflow, which the account owner activates. Request one run at a later time, set by delay_seconds or fire_at (RFC 3339). Nothing is scheduled until the account owner confirms the request at confirm_url in the Plori web app: until then its status is awaiting_confirmation and it never fires, and the calling model cannot confirm it. A request whose fire time passes before the owner confirms it is not armed. Returns the request with its prompt, fire_at, status and confirm_url. The run it starts is charged like any run, and its actions outside the agent's own environment pause for the owner's approval one action at a time, as for any run started through this connector.

Use this when a build, research or recurring report should run in the background or after the chat ends. Do not use for quick lookups. Send a message to a Workspace's main conversation, or to another of its conversations named by session_id; the Workspace's agent runs it. The run works on the Workspace's current files and saves them as a new revision when it ends. Returns the run with agent_id and workspace_id. A completed run has text (the agent's reply), the files the reply linked, a url to the conversation in the Plori web app, and its credits and tokens; file_source.state ready and no save_failure mean its files are saved. A run still going has status "running", run_id and poll_after_seconds, and continues after this call returns. A paused run has status "awaiting_input" and lists its requests; tell the person each approval's approve_url and who it is assigned to. A run started through this connector pauses before each action outside the agent's own environment (connected-account, MCP and outbound HTTP writes, git push, publishing, deploys, email) until the account owner approves that one action in the Plori web app; the owner's standing approvals do not apply and the calling model cannot approve. While the conversation is running or paused, a plain-text message is accepted as steering or queued (steer_id), or answers an ordinary question assigned to its sender, and never cancels a pending request. A message with attachments or run options gets 409 conversation_busy until the conversation is idle: keep them and resend once it is idle. Runs are charged to the account's prepaid US-dollar balance; a run the balance cannot cover is refused with 402. idempotency_key identifies the request for 24 hours: the same key with the same arguments returns the original result, and the same key with different arguments is refused.

Send a message into a worker's running turn, for example to correct its direction, without stopping it. run_id is the worker's run_id from get_workspace_worker; a run started by send_workspace_message is also accepted. The agent reads the message before its next step and continues the same run; disposition steering means the running turn holds the message. A run that is not running (not started yet, paused on an approval or question, or ended) is refused with 409 run_not_running: answer a paused run with answer_pending_input. If the running turn cannot take the message, for example because it is ending, the message is withdrawn and the call is refused with 409 steer_not_delivered. A message sent through this connector makes the run's later outward actions pause for the account owner's approval, as for a run started through this connector. idempotency_key identifies the message: the same key with the same message returns the first result instead of sending it twice.

Stop every worker of a task group: workers that have not started never start, and running worker runs are cancelled. Their copies, saved revisions and agents are kept. Plori does not submit a stopped worker's files; submit_workspace_changeset can still submit a worker whose files are saved. The group starts no new workers afterwards. To stop one running worker only, use cancel_run with its run_id and workspace_id. Returns the group state (stopping until every run has ended, then stopped) and the runs whose cancellation was requested.

Submit a worker's saved files for review as a changeset: Plori compares them with the Workspace's current files. Plori submits a worker's saved files itself when its run completes normally and they change at least one file, and accepts a clean comparison; use this tool for a worker whose change_status is still unsubmitted after its run ended in error, was cancelled or was stopped, or after phase recompare_required. Submitting a worker that Plori submitted returns that changeset. The worker must have save_state ready (get_workspace_worker); otherwise the call is refused with 409 workspace_worker_not_saved. The Workspace's files do not change. The comparison runs after the call returns: poll get_workspace_changeset until compared is true, then accept_workspace_changeset accepts a changeset in phase review_ready and reject_workspace_changeset rejects one. Submitting the same worker again while the Workspace's current revision is unchanged returns the same changeset; after the current revision changes, for example because another changeset was accepted, it creates a new changeset compared with the new current revision.

Write a file into a Workspace's current files, replacing any file at path. For UTF-8 text up to 262144 bytes, pass it as content: the file is written before the call returns. For a larger or binary file, omit content: the call returns upload_url and a curl command that uploads one local file of up to 33554432 bytes (32 MiB). Run the command in a shell within 10 minutes. The URL needs no other credential and accepts one upload. While a run uses the Workspace's files, the write is refused with 409 agent_busy. Try again after the run ends. Members and viewers of a shared Workspace cannot write files (403).