Skip to content

Releases

AgentRun v0.1.0-beta.47

Pre-release

Choose a tag to compare

@github-actions github-actions released this 19 Nov 21:13
27abab8

This release publishes the ACP harness package, so a server installed from npm offers Goose and Cursor once their pinned release is installed (agentrun harness install goose or cursor), and any ACP agent can be brought in as a recipe. AgentRun Server gets a Helm chart published with each release and Coolify and Dokploy templates. An ended run reads its booked cost instead of null, a compacted pi run reads its priced cost, and a run's cost carries its tokens, how its figure was reached and what its paid tool calls cost. A Composio server can act as each run's own account and price its calls, a model gateway is saved from the console, run notices post to Slack, agentrun doctor checks a setup, and a server whose runners all refuse to claim says so instead of queueing runs for good. The store moves on Postgres (migration 0020) and changes a table on SQLite: back up before you upgrade, since going back to beta.46 is that backup.

Upgrading and going back:

  • The store moves: Postgres migration 0020_runners.sql renames the runners' relay table runner_relays to runners in place, keeping its rows. beta.46 refuses a Postgres schema at migration 20 ("set up by a later release than this one"), so going back on Postgres is a backup of the schema taken before the upgrade. SQLite stays at version 13: the server's start drops runner_relays and makes runners, whose rows are heartbeats each runner writes again within 10 s. beta.46 opens such a data folder, but its runner in a process of its own with a public address (the image's default command with AGENTRUN_PUBLIC_URL set, or on Render) does not start, since the table it writes its relay to is gone. Back up the data folder or the Postgres schema before you upgrade; going back to beta.46 is that backup and the beta.46 image or package. From beta.44 or older, beta.45's notes hold first.
  • Start the server before any runner of its own. A runner started on a store this release's server has not opened yet stops with exit 3 on SQLite and Postgres alike: "The store in is behind this runner: start the server first, which upgrades the store in place, then the runner." The image's two processes start in that order. A beta.46 runner with a relay does not start against a store this release's server opened, so upgrade the runners with the server.
  • At each start the server heals, in the background, the ended runs whose stored cost is unknown while their booking is priced: it writes the booked figure once, in place of the unknown, and logs one cost_heal line with counts and no ids. A stored figure is never written over. The healed figures stay if you go back.
  • The server now sends anonymous usage counts, as docs/telemetry.md lists: a random id made for the data folder (kept in its .telemetry.json), the version, the platform and how many runs ended there as a range, never prompts, files, keys, names, paths or addresses. The first start that can send prints a notice and sends nothing until its first heartbeat a day later. AGENTRUN_TELEMETRY=0 or DO_NOT_TRACK=1 where the server starts turns it off; it is already off in CI, under a test runner and under --faux (#3191).
  • A run-list row a beta.46 or earlier server cached is not rebuilt for the new path and workflow fields, so GET /v2/runs and an agent's runs list can show such a run without them until the run changes. GET /v2/runs/{run_id} has both (#3258).

Breaking:

  • A run's read and each runs-list row carry one path and workflow: { name, digest } (the learned workflow that served it, null on any other run). The learning cost read's bill drops baseline and promoted: read summary.before and summary.takeover instead (#3229).
  • Daytona no longer offers a desktop on any connect (none ever started: its sandboxes block the tool user's namespaces): { kind: "desktop", provider: "daytona" } is refused with the reason (#3245).
  • @parcha/agentrun-harness-acp no longer records a binary's first-seen digest itself: fileDigestRecord, verifyFirstSeen, DigestRecord and ACP_BINARY_DRIFT are gone. Pin the binary's sha256 and call verifyPinnedBinary, or install it with agentrun harness install --recipe (#3238).
  • agentrun native takes only the flags it names: --base-url (use --url) and --json are refused, exit 2 (#3225).
  • A run's cost basis reads reported, estimate or unpriced, no longer always estimate; a run with no model request reads unpriced (#3145).
  • A refusal's words changed where a client may have matched them: a secret write refused to the API token ends with a console link (match the sentence it starts with), and a refusal a start-time switch causes names the switch (match the error code, which is unchanged) (#3137, #3132).

Known issues:

  • Under the image's default command, no run can use a paired computer, a paired Linux sandbox included. Start the image with the server's options alone for one.
  • A learned workflow refused for a host setting (a tool gated, denied or missing) still reads serving, while every run it is given hands back to the agent. A workflow this release's DSL refuses is held.
  • For up to about 10 minutes after the release is published, an install can fail while npm shows the new packages one by one. Try again a few minutes later.
  • An API token's GET /v2/settings/calendar is refused 403 in the words for saving a secret. Reading the calendar's settings takes the owner's signed-in session in the console, as saving them does.
  • Fixed: a runner of its own started on a Postgres store before its server had upgraded it said to start on a new, empty data folder. It now says to start the server first, on SQLite and Postgres alike (#3205, #3227).

Changes:

Harnesses

  • @parcha/agentrun-harness-acp, the adapter that runs an Agent Client Protocol agent as a harness, is published with this release, after the kernel and before the server, and the server depends on it. A server installed from npm offers Goose once its owner installs Goose's pinned release (agentrun harness install goose, or agentrun-serve install-harness goose --data <dir>) and restarts it. Goose 1.59.2 is pinned for Linux x86_64 and Apple silicon Macs, and its model requests go through AgentRun's model proxy under the run's cap (#3195).
  • Cursor runs as a harness (cursor) over ACP, on its owner's own Cursor API key: install its pinned release with agentrun harness install cursor, set CURSOR_API_KEY where AgentRun starts, and restart. Each run is billed to your Cursor plan, with no spend cap of AgentRun's: it stops after 20 turns or 100 tool calls (AGENTRUN_CURSOR_MAX_TURNS, AGENTRUN_CURSOR_MAX_TOOL_CALLS). Cursor makes no file edits (every Write is denied in its CLI config), and its own shell commands and calls are asked of a person who can approve them and refused where no one can. The key goes to Cursor's runs alone and the credential Cursor derives from it is never written to disk. A model is cursor/<model-id>, checked against the models Cursor lists for the key. The release is pinned by its archive's, launcher's and every unpacked file's digest, for Linux x86_64 alone: on any other host, a Mac included, Cursor is refused ACP_BINARY_UNPINNED (#3238).
  • Bring your own harness, door 1: a recipe. A JSON file names an ACP agent's registry release (the archive's URL and sha256, the binary inside it), its billing (through AgentRun's model proxy, or the owner's plan with turn and tool-call limits), its literal env, files and session folders in a private HOME. agentrun harness install --recipe FILE installs it, and agentrun harness-check --recipe FILE --model PROVIDER/MODEL runs it for real: its own tools off, its environment an allowlist, the cap or plan limits, the pinned binary at every start, a kill and resume, a denied call, one of AgentRun's tools over MCP and a second runner, then writes a JSON report and prints the resume, tool_gate and billing facts. The loader refuses a recipe that breaks one of five rules by its code (RECIPE_KEY_NOT_OWN, RECIPE_BINARY_UNPINNED, RECIPE_PATH_OUTSIDE, RECIPE_INSTALLS_ITSELF, RECIPE_ENV_NOT_ALLOWLIST), and a binary that differs from the one its install recorded is refused HARNESS_BINARY_MISMATCH. See docs/harness-recipe.md and HARNESS-SCORECARD.md, which rates 25 agents (#3231).
  • The ACP adapter ties Goose's tool title (agentrun: <tool with spaces>) to AgentRun's tool, so the host's gate is asked once per call (#3249). harness-check's gate refuses every call that is the agent's own, so a call of AgentRun's tool the adapter can't tie fails mcp_tool instead of passing, and its tools_off stage passes once the agent's first model request reached the provider; the adapter's and the model proxy's environment variables are one list (#3257, #3251).

Runs and the server

  • A server whose runners all refuse to claim (their run isolation refused, such as an AGENTRUN_RUN_USER the runner does not know, or the image's helper unable to switch users on the platform) now says so instead of queueing runs forever. A start is 503 runner_refused with the runner's words and their fix (set AGENTRUN_RUN_USER=same), a run already queued ends failed with runner_refused, GET /v2/capabilities carries the words in runner_refused, and GET /v2/health answers 200 degraded with its runner check refused, so a platform's health check does not restart the service in a loop. A message to a run and a backend SDK run's start are refused the same way, and it all clears once a runner that can claim starts. Each runner keeps a row in the store saying it is there, judged on the store's clock, so a runner on another host whose clock drifts is no longer refused as not running. A serv...
Read more

AgentRun v0.1.0-beta.46

Pre-release

Choose a tag to compare

@github-actions github-actions released this 18 Nov 18:30
8052a92

This release keeps a runner whose run isolation is refused up and refusing runs, so a Render or Railway server no longer restarts in a loop. A learned workflow's check can compare answers on the fields that carry the decision instead of word for word, the agent editor's Computer step gets a Recording switch that a change of provider keeps, and the run page's Dev tools tab reads as a browser's network panel does. The store doesn't change, so going back to beta.45 is the image alone.

Upgrading and going back:

  • The store doesn't change (SQLite version 13, Postgres migration 0019): beta.46 opens a beta.45 data folder as it is, and going back to beta.45 is the image or the package alone. From beta.44 or older, beta.45's notes hold first: its store move is one beta.44 refuses, so back up before you upgrade.
  • A Render or Railway server that runs the image without AGENTRUN_RUN_USER=same and can't start the runner's run-as helper (spawn EPERM) now stays up and refuses runs, saying to set AGENTRUN_RUN_USER=same; on beta.45 its container stopped and restarted in a loop. Both templates set it; a server deployed from either before beta.45 needs it added.

Breaking:

  • None.

Known issues:

  • Under the image's default command, no run can use a paired computer, a paired Linux sandbox included. Start the image with the server's options alone for one.
  • A runner of its own started on a Postgres store before its server has upgraded it says to start on a new, empty data folder. Don't: start the server first, which upgrades the store in place, then the runner.
  • A learned workflow refused for a host setting (a tool gated, denied or missing) still reads serving, while every run it is given hands back to the agent. A workflow this release's DSL refuses is held.
  • For up to about 10 minutes after the release is published, an install can fail while npm shows the new packages one by one. Try again a few minutes later.
  • An API token's GET /v2/settings/calendar is refused 403 in the words for saving a secret. Reading the calendar's settings takes the owner's signed-in session in the console, as saving them does.

Changes:

Runs and the server

  • A host that won't let the runner start a run as a user of its own (a spawn EPERM, as on Render) leaves the server up: the runner says why and claims no runs (AGENTRUN_RUN_USER=same lets it), instead of stopping the container. Any refusal of the runner's isolation does this, in the image's two processes and in a server with its runner in its own process. The server still serves its console and API, and its runs wait queued until the setting is fixed and the server restarts.
  • Outbound webhook messages name their agent, so a receiver no longer reads the trigger or the agent back to know whose it is: trigger.failed adds agent_id and agent_name, and run.ended and run.needs_input add agent_name beside agent_id (the agent's id when it has no name). No field is removed or renamed, and a message still carries no run output or input (#3130).

Learning

  • A learned workflow's check and its shadow audit can compare two answers on the fields that carry the decision instead of word for word: a definition's learning takes agree_on, dotted paths into the answer's JSON object (["verdict.decision"], ["mcc", "riskTier"]; 1 to 16 paths, a bad one a 422 under definition.learning). Each path must resolve to equal values in both answers; one missing on either side disagrees. Left out, the whole answer is compared as before, and a check that agreed on none says to name the fields. The kyb template declares verdict.decision and inbound-lead next_step.action, and a template's learning takes the same object, each path a required field of its output schema. The check record keeps agree_on, the console's check line says "compared the whole answer" when there was none, and the TypeScript and Python clients' types carry it (Python 0.3.14). (#3182)

Agents and templates

  • An imported agent runs as imported. A project with no CLAUDE.md or AGENTS.md gets short instructions of the import's own, and a Codex session's model is kept only when a model catalog here lists it; otherwise the agent runs on the server's default model for its harness, and the import says so for each one. Before, both made every run of the agent refused 409 agent_not_runnable. An agent imported earlier keeps its revision: set its model and instructions on its page, or import again into a new data folder (#3155).

Console

  • The agent editor's Computer step has a Recording switch for a desktop, a phone or a browser, with a note that a recording holds everything on the screen, what a person types after taking over and any password shown included. A switch of provider, or to another kind that records, keeps it on; a switch to a sandbox or to no computer turns it off and says so. Before, any switch dropped record. A server without ffmpeg refuses the save, in words the step shows (#3194).
  • The run page's Dev tools tab reads as a browser's network panel does: each row carries its bar on the time axis under a compact overview, a zoom or a drag across the overview lists only the calls in that part of the run, a call's panel has a Timing section, and the Breakdown view opens with the run's vitals (first answer, first tool call, largest input, most calls at once, longest pause). The table is one stop for the Tab key, its rows moved through with the arrow keys, and it reads under a forced-colours theme and to a screen reader (#3189).

Docs and release

  • The server README's Particle-1 section records a live pass against Particle's API: a saved key, a plain run, tool calls after the model's reasoning, a follow-up, a cancel, a capped run and a workflow's model nodes, each priced run's cost equal to its tokens at list price. Not yet seen live: a rate limit or server error from Particle, and the estimate against Particle's own bill (#3190).
  • A release no longer posts to Slack on its own: whoever cuts it posts its summary once the release page is out, in the shape docs/releasing.md gives (what you can do now, three lines before you upgrade, the install lines and the notes link).
  • beta.45's changelogs now tell the four changes its tag carried past its release pull request's fold as its release page did, under 0.1.0-beta.45, with a known issue for a Render or Railway upgrade to it.
  • Tests: the steer-mid-turn test's failure names the steer's outcome and what the model was handed, and a relay test that read the server's log before the line was written is deleted (#3192).

Install

  • Server: npx @parcha/agentrun-serve@0.1.0-beta.46; every @parcha/agentrun-* package of this release is 0.1.0-beta.46 on npm
  • Launcher and CLI: npx @parcha/agentrun@0.4.14
  • Python client: pip install parcha-agentrun==0.3.14
  • Server image: docker pull ghcr.io/parcha-ai/agentrun-server:v0.1.0-beta.46 (linux/amd64, linux/arm64)

AgentRun v0.1.0-beta.45

Pre-release

Choose a tag to compare

@github-actions github-actions released this 18 Nov 16:19
afe3f99

This release runs each run in a process of its own. In the Docker image each run is also a user of its own, so its tools can't read another run's folder or the store. A local install runs every run as the user who started the server. The image now starts the server and its runner as two processes, and run lists read one row per run, so a list costs the same at ten runs and at thousands. Learning comes down to two things an agent keeps: its owner's corrections and its compiled workflow. Computers without an Archil mount hold a run's folder as a synced folder, a Linux box of your own pairs as a computer, and a dial computer can be a desktop. Claude Agent can run on Claude Code's own login on a server one person runs, install.sh --vps sets AgentRun up on a rented Linux server, an agent another system owns can be deleted, a template can update the agent it made, and a run's page has a Dev tools tab with the run's trace.

Upgrading and going back:

  • Back up the data folder (and the Postgres schema, if you use one) before you upgrade: the first start moves the store to SQLite version 13 or Postgres migration 0019, which beta.44 refuses, so going back means restoring that backup (#3123, #3133, #3170).
  • The image now runs server-and-runner by default, the server and one runner as two processes. Under it a paired computer needs the server's options alone instead, and a computer that dials the server needs the server's public address in AGENTRUN_PUBLIC_URL (#3123, #3170).
  • Start the server before any runner of its own: a runner refuses a version 11 or 12 store until the server has upgraded it. After the upgrade the server builds each run's listing in the background, the runs no runner holds first (#3123).
  • Each run now runs as a process of its own, and in the image as a user of its own: slot s of a runner runs as uid and gid 1001 + s, so a run's tools can't read another run's folder or the store. GET /v2/capabilities says which as run_isolation ("uid" or "process"). A local install runs each run as a process of its own under the user who started the server (#3128).
  • A learning run, an SDK backend run and a native run stay in the runner's process (#3128).
  • In the image, the runner starts runs through a helper that needs its file capabilities. On a platform that strips them, or that starts the container with no-new-privileges (Docker's no-new-privileges:true, Kubernetes' allowPrivilegeEscalation: false), the runner claims no runs and says why: "This runner will not claim runs: it cannot start a run as a user of its own (...)". Allow them, or set AGENTRUN_RUN_USER=same to run every run as the runner's own user, each still in a process of its own (#3128).
  • Where each run is a user of its own, a claude-agent run on Claude Code's login on this machine that has no model_key of its own fails when it is claimed: "A run on Claude Code's login on this machine needs runs under the server's own user, and this runner runs each run as a user of its own: set AGENTRUN_RUN_USER=same, or give the run a model_key." Set AGENTRUN_RUN_USER=same on that server, or send the run a model_key (#3124, #3128).
  • A run that brings its own model_key runs on that key alone: its runner opens it and hands it to that run's process, and the run gets none of the server's model keys (#3128).
  • Runners in containers of their own on one data volume each take their own range of slots with AGENTRUN_RUN_SLOT_FIRST (deploy/compose.yaml gives 0 and 128). A runner told to hold more runs at once than its range reaches refuses to start (#3128).
  • The data directory is now mode 0711 and the store's files 0600. The Railway template's start command sets its volume to 0711 (#3128).
  • Going back after runs ran on beta.45: restore the whole data folder from before the upgrade. A run's files that beta.45 wrote belong to that run's user, which beta.44's server can't read (#3128).
  • Remove --learning-budget and --grade-model from the server's start command: the server no longer takes them and won't start with them. An agent's notes and learned skills are no longer served; put what an agent should always follow into its corrections.md, one - line each (#3097).
  • The Cloudflare relay's box image moved to this release's recipe (ghcr.io/parcha-ai/agentrun-box:87f44537b8b7, which this release publishes). Redeploy the relay from beta.45 once the release is out to give Cloudflare computers the new box, desktops included. RELAY_VERSION stays 1, so a relay from beta.44 keeps working (#3167).

Breaking:

  • Image: the default command is server-and-runner, and render.yaml and the Railway template run it too. An operator who gives the image server options of their own still gets one process with the runner inside it; put server-and-runner before them for two. On the default command a paired computer is refused, and so is a provider whose machines dial the server while the runner has no public address: every provider row and paired computer in GET /v2/computers carries runs_refused, null where runs can use it, and the console shows it (#3123, #3170).
  • Image: on a platform that strips file capabilities or sets no-new-privileges, the runner claims no runs until the platform allows them or AGENTRUN_RUN_USER=same is set. The Render and Railway templates set AGENTRUN_RUN_USER=same; a server already deployed from either and moved to this release needs that variable added in its environment, or its runner claims no runs (#3128).
  • Learning: notes, learned skills, the look-back turn and the learning grader are gone. Removed: GET .../learning/notes, PUT .../learning/files/{file}, POST .../learning/workflows/{name}/promote, the learning batches and evals, the server options --learning-budget and --grade-model, capabilities.learning.grade_model, and a definition's learning: "notes". A grade's feedback round is correction (was look_back); a run's learning carries corrections and workflows, not given, read, learned, pending or verdict. The clients' learning.notes and learning.write are learning.corrections and learning.writeCorrections (Python write_corrections). A native target's capabilities.notes and capabilities.skills are one capabilities.learning (#3097).
  • Learning cost: a cost run has digest, took_over and audited in place of learned_revision, and a replay run's n is null. GET /agents/{id}/learning's impact sides are runs and median_duration_s only: read a run's cost before and after learning from the cost read's summary, and what learning costs a run from bill.learning_usd (#3166).
  • @parcha/agentrun-computer: ARCHIL_MOUNT_LABEL is MOUNT_LABEL; RecordedArchil, recordedArchil and readArchilMount are RecordedFolder, recordedFolder and readMount; syncingClient(client, sync) takes the sync it runs, archilSync(client) for an Archil mount (#3118).
  • Tool keys: GET /v2/settings/tool-keys (listToolKeys) names a key row's harnesses by harness id: items[].harnesses is an array of strings, no longer only the four built-in names, since a harness its owner installs (goose) is named there once it is installed. The TypeScript and Python clients and the console say string[]; a caller that switched over pi, claude-agent, codex and opencode handles any other id too. (#3176)
  • GET /v2/agents/{id}/learning: each workflow's status is now serving, checking, held or stopped (the state GET .../learning/promotions gives it), else pending or retired. active is gone: a reader that tested status === "active" for a workflow given to runs tests that it is neither pending nor retired (#3179).

Known issues:

  • Upgrading an existing Render or Railway server without AGENTRUN_RUN_USER=same stops the container (it restarts in a loop) instead of refusing runs. Add the variable before you upgrade. beta.46 makes it refuse as described.
  • Under the image's default command, no run can use a paired computer. Start the image with the server's options alone for one.
  • A runner of its own started on a Postgres store before its server has upgraded it says to start on a new, empty data folder. Don't: start the server first, which upgrades the store in place, then the runner.
  • A learned workflow refused for a host setting (a tool gated, denied or missing) still reads serving, while every run it is given hands back to the agent. A workflow this release's DSL refuses is held, as in beta.44.
  • For up to about 10 minutes after the release is published, an install can fail while npm shows the new packages one by one. Try again a few minutes later.
  • An API token's GET /v2/settings/calendar is refused 403 in the words for saving a secret. Reading the calendar's settings takes the owner's signed-in session in the console, as saving them does.

Changes:

Runs and the server

  • Each run is a process of its own under its runner, and in the image a user of its own. The run's process gets its own keys on a pipe and talks to its runner over a channel; the seal key, the API token and the store's address stay in the runner. What a run is handed is bound to its claim: a GitHub token only for its own pull request's repository, read-only, and decision and tier model keys only for the learned workflows its runner chose for it. When a run ends, every process of its user is stopped and its files in the shared temporary folders are removed. A learning run, an SDK backend run and a native run stay in the runner's process. (#3128)
  • GET /v2/runs and an agent's runs read each run's listing from its row: the status filter, the order, the limit and the cursor are one query, so a list costs the same at 10 runs and at thousands, however long their journals. Each item is what GET /v2/runs/{id} gives for the run, as before. The image runs the server and one runner as two processes (server-and-runner), so a busy runner's journ...
Read more

AgentRun v0.1.0-beta.44

Pre-release

Choose a tag to compare

@github-actions github-actions released this 18 Nov 01:12
ce75f14

Upgrading and going back:

  • Keep the same data folder and start command, and change only the image. No store schema changes in this release: SQLite and Postgres stay at the versions beta.43 set up, so going back is setting the image back to v0.1.0-beta.43.
  • A server with a model gateway (AGENT_MODEL_BASE_URL) and no AGENT_MODEL_API_KEY used to send none as the key. Its runs now need a model_key, or start with 422 model_key_required. To keep the old behavior, set AGENT_MODEL_API_KEY to any value before you upgrade.
  • Before going back, let runs that brought a model_key end. beta.43 does not read a run's own key, so a turn it claims for such a run uses the server's key (or none).
  • At its first start, beta.44 seals the credential fields of each Composio trigger's config and stores [sealed] in their place. Composio's own copy of the trigger is not changed. After going back, beta.43 shows [sealed] for those fields.
  • Run costs: a run's cost.usd is now its job's own spend. Anything that reads it as what the run cost with learning should read the new cost.all_in_usd. An audit's shadow run no longer sends a webhook (#3087).

Breaking:

  • API: a run whose model goes to the gateway with no key to spend is refused 422 model_key_required, as is a message that would start a new turn without one, and a trigger's firing on such a server fails the same way. model_key on a run whose model never goes to the gateway is 422. The model_key entry in packages/serve/CHANGELOG.md has the details.
  • API: a harness id is now a string (pattern ^[a-z][a-z0-9-]{0,39}$), not an enum of the four built-in harnesses, and tools[].harnesses lists ids of the harness table. A typed client that matches harness ids exhaustively needs a default case.
  • API: a Composio trigger create whose config holds a credential below its top level (inside an object or a list) is refused 422, naming the field.
  • Run costs: a run's cost.usd (GET /v2/runs/{run_id}) is now its job's own spend. What learning spent for the run (its look-back, its grade, its audit's shadow run, and its share of its workflow's compile and check) is in the new cost.learning_usd, and cost.all_in_usd is the two. An audit's shadow run sends no webhook and is no run in GET /v2/stats or the analytics' counts; their dollars carry its cost with the run it audits. Run dollars are as booked, no longer rounded to a millionth of a dollar. The TypeScript and Python clients' types carry the new fields (#3087).

Known issues:

  • None new in this release.

Changes:

  • Daytona computers can dial the server instead of being reached through the toolbox: set connect: "dial" (the server's daytonaConnect setting, or COMPUTER_DAYTONA_CONNECT for the conformance module). Exec stays the default. On dial the sandbox gets the boot env as its env, and the box snapshot's entrypoint runs agentrun-dial. Daytona runs a snapshot's entrypoint, never the image's CMD, so box/build-daytona.py now names the CMD as the snapshot's entrypoint, and names the snapshot agentrun-box-<recipe hash>: the agentrun-archil-<recipe hash> snapshots it built before have no entrypoint and never dial. A server on exec that names one of those keeps working. On dial a Daytona computer takes no Archil mount, no GPU and not Daytona's default snapshot, each refused in words, and the conformance module's dialKit() refuses, as E2B's and Modal's do. On dial the module's run image is agentrun-box-<recipe hash>.

  • A harness is one entry in serve's harness table: capabilities, a revision's save check, the runner and the console all read the table. An owner can add harnesses with a harness module. Start the server (and any separate runner) with --harness-module MODULE (repeatable) or AGENTRUN_SERVE_HARNESS_MODULES (comma-separated). MODULE is a path, or a package installed with npm install --prefix <data>/harnesses <package>, that exports the entries(builtins) shape test tables already use.

    A module adds whole entries of new ids. A module's harness runs on its own runner's adapter, and a run of it reserves the memory its entry declares (runMib). A module's harness without adapter facts runs pi's tools, and capabilities list it on each of those tools (tools[].harnesses, now ids of the table, not an enum) and on MCP grants, so an agent on it keeps its tool choices. A module that gives an id outside ^[a-z][a-z0-9-]{0,39}$, names an id serve's own runs carry (learning, sdk, workflow, claude-agent-sdk, codex-sdk) or every object already has (constructor), names a built-in harness (pi, claude-agent, codex, opencode), names an id another module adds, or leaves out a member refuses the start of the server or of a separate runner, naming the module and the id.

    Capabilities' harnesses now carry each harness's label and promises: resume (exact, load, restart), tool_gate (every_call, permission, config) and billing (proxy, plan). The built-in harnesses promise exact resume, every call gated, and proxy billing. A harness id in the API is now a string (pattern ^[a-z][a-z0-9-]{0,39}$), not an enum of the four built-in ones. The console offers a harness the server adds after the built-in ones, under the label the server gives it; one named decision stays a harness, never the Decision starter.

  • curl -fsSL https://agentrun.ai/install | sh installs AgentRun on macOS or Linux (x64, arm64) with no Node.js needed. It downloads from nodejs.org the newest Node.js on the major line of the launcher's engines floor that is at least that floor, so later security releases come with the next install, and checks it against that release's SHASUMS256.txt. It installs that Node and the launcher under ~/.agentrun (node/, lib/, bin/agentrun), leaving any other Node, nvm or Homebrew alone. It adds one PATH line to your shell's startup file when none is there, and starts AgentRun as a service of your user, which keeps running after the terminal closes and starts again at login. Where there is no service manager, as in a container, it starts AgentRun in the background until the machine or container stops. Either way it returns once AgentRun answers and prints its address. --no-start, --version V, --node-version V and --service change that; running it again upgrades.

    • agentrun service install|status|start|stop|restart|logs|upgrade|uninstall runs AgentRun as a launchd LaunchAgent on macOS or a systemd user unit on Linux, with --no-open and the launcher's data directory and port rules, logging to ~/.agentrun/logs/agentrun.log. status prints the console's address and health. On Linux it prints the one sudo loginctl enable-linger line when lingering is off, and never runs sudo itself.
    • agentrun stop stops the AgentRun the installer started in the background: a SIGTERM, then a SIGKILL after 45 seconds, and it returns once the launcher and its server have both ended. The installer stops it the same way before it starts another version, including one from before agentrun stop.
    • agentrun --version prints the launcher's version. On a Node.js below the floor, the launcher's error names the installer's command.
  • More of a Composio trigger's config credentials are now sealed.

    • The name rule reads each word as its singular, so tokens, secrets, api_keys and private_keys are sealed. It also takes hapikey, pat, pwd, passcode, jwt, dsn and connection_string. Names such as key_id, keyword, status, pattern, path and address stay as they are.
    • A field that the event's schema marks with format: "password" or writeOnly: true is sealed whatever its name, and the events list names it under sealed. To check this, the create now reads the event's schema from Composio.
    • A number in a credential's field is sealed like a string, at any depth. Composio still gets it as a number, and answers show "[sealed]". A PATCH that leaves it out keeps it. A run's output is cut of its decimal text when that text is 8 characters or more.
    • On SQLite, the cleanup after the start-time sealing waits briefly and tries once more when another connection is writing to the store. If it still can't finish, the log says store_scrub_not_done and the next start finishes it.
    • Deleting a trigger retires its sealed values into a sealed row until the runs that saw them end. The docs used to say the values are removed.
  • A Composio trigger's config seals addresses that carry a credential, and stops sealing counts.

    • A credential word right next to a count word names a count, so max_tokens, token_count, token_limit, tokens_used and maxTokens stay as they are, a number in one too. access_token, token, api_tokens, refresh_token, token_secret and bot_token are still sealed. A field the event's schema marks as a password is sealed whatever its name.
    • An address in any scheme (https, postgres, redis, amqp, mongodb+srv...) with a user part (user:pass@, :pass@, or a token alone as in https://TOKEN@host), or with a query or fragment parameter named like a credential (token, api_key, access_token, sig), is sealed whole, whatever its field's name. A create with one below the config's top level is refused 422; one an earlier server kept is masked on reads and sealed at the next start. An address with none stays as it is.
    • After a start, the server reads the schema of each event an older trigger uses, once, and seals the fields it marks, logging composio_config_sealed. A create answer kept under an Idempotency-Key for that trigger is masked too. If that file can't be written, the log says idempotency_not_saved with a code and the trigger stays sealed; the next save writes the record masked, and a start before then masks it before serving: each kept create answer is checked against its trigger's sealed fields. It writes a trigger only while it is as ...
Read more

AgentRun v0.1.0-beta.43

Pre-release

Choose a tag to compare

@claudio-michel claudio-michel released this 17 Nov 14:42
e6e0ed4

AgentRun 0.1.0-beta.43

AgentRun is an open-source platform that supercharges your agents. It adds self-improvement, durable execution and a
control plane on top of your favorite agent harness. Your agents become smarter, more fault tolerant and use fewer
tokens with every run. This release is about learned workflows you can keep trusting. The old promotion loop is gone:
a learned workflow has one path to serving, its one check against the agent's own answers, then promote, or hold and
one recompile. Once it serves, a sample of its runs is answered again by the agent itself, and too many disagreements
hold it. The release also fixes the Cloudflare relay's bare 500 on a slow create and the CPU cost of importing large
Codex histories. The store does not change: SQLite keeps schema version 11 and Postgres version 16, so going back to
beta.42 is changing the image back on both. The launcher is @parcha/agentrun 0.4.11, the Python client
parcha-agentrun is 0.3.11, and the server image is ghcr.io/parcha-ai/agentrun-server:v0.1.0-beta.43 (linux/amd64
and linux/arm64).

No fresh store: beta.43 opens the data beta.42 left. Keep the same data folder and the same start command, and
change only the image to ghcr.io/parcha-ai/agentrun-server:v0.1.0-beta.43. Your agents, triggers, runs, settings
and learning folders are all still there.

  • No store change. SQLite stays at schema version 11 and Postgres at 16 (0016_minted_tokens), with no migration
    and no new table or column, upgrading or going back.
  • Learning records from beta.42. A promotion record beta.42 wrote as queued or skipped is left out of every
    read, and its revision is checked again at the agent's next run. Fields this release dropped (source, replay,
    refit and the rest) are ignored. Nothing is deleted from the store: beta.42 shows those records again if you go
    back.
  • Delete guard from every learned workflow. beta.43 does not run a learned workflow whose workflow.json still
    has a step guard: each run says "the workflow DSL refuses it: NODE_KEY_UNKNOWN ... unknown key(s) for a extract
    node: guard", hands the job back, and the agent answers. The promotions read still says that revision is
    serving. An agent with learning history from before this release can also turn learning off and on (or delete its
    learning folder) to start clean.
  • Going back is setting the image back to v0.1.0-beta.42, on SQLite and on Postgres alike: beta.42 opens the
    store beta.43 used, with every agent, trigger, run and setting in it, and no pg_dump restore is needed. What
    beta.42 does with what only beta.43 writes:
    • An agent whose learning sets any of the audit numbers: beta.42 reads it back as saved and runs the agent. It
      refuses to save a new definition of that agent (422 wrong_type on definition.learning,
      "definition.learning.audit_every is not one of the loop's numbers: compile_after, agree_min, alone_min"): to edit
      it on beta.42, take the six audit numbers out, and set them again once you are back on beta.43.
    • Promotion records in this release's shape (no source, decided: "replaying", check.unstarted, a hold with
      audit): beta.42 reads them, and a workflow beta.43 held stays off its runs. Its serving entries have none of
      the five new fields, and its loop read answers with its own guards list, empty for a workflow with no guard.
    • Audits: beta.42 starts no shadow and has no audits route (404 "no route /agents/{agent_id}/learning/audits").
      audits.jsonl stays in the learning folder, and beta.43 reads every row again on return.
    • Shadow runs: beta.42 lists a shadow that beta.43 started as an ordinary run, in GET /v2/runs and in the agent's
      run list, with no audit_of, and the served run's cost.usd leaves the shadow's cost out. Back on beta.43 the
      shadow is out of the lists again and reads with audit_of.
  • Clients: stop reading guards, a promotion record's source, replay and refit, and the queued and
    skipped decisions; read check. A client that builds the promotions read's serving objects must add state,
    check, audit, audits_off and not_auditable, and a served run's cost.usd can be null while its shadow runs.

Highlights

  • A learned workflow has one path to serving. A new revision serves only once its one check against the agent's
    own answers promotes it; a hold asks one recompile, and a held recompile stops. Nothing else moves it: the threshold
    refit, the graded hold, the graded replay, the queue of revisions, rival settles, step guards, the Jev generality
    pre-check and the quiet window after a compile are deleted. A revision waits for a running check and records
    nothing. An owner's replay (POST .../learning/workflows/{name}/revisions/{digest}/replays) re-checks a revision on
    the agent's own completed runs: inputs: "held", the runs its last check ran on, or a number from 1 to 200 of the
    newest; with no earlier check it picks the agent's last compile_after completed runs. The console's cost card
    reads "Passed the agreement check: N of M agreed (bar 80%)" (#3064).
  • Serving workflows are audited against the agent itself. A run a promoted learned workflow serves first is drawn
    at 1 in learning.audit_every (10), then 1 in learning.audit_every_later (20) once its revision has served
    learning.audit_later_after (50) runs, seeded from the run's id. A drawn run starts a shadow run at its end: the same
    agent on the same input with learning off. Each finished audit is a row of audits.jsonl in the agent's learning
    folder, read with GET /v2/agents/{agent_id}/learning/audits (run, shadow_run, workflow, digest,
    promoted_at, source, agreed, served_cost, shadow_cost, turn, at), and an owner's grade of a run the
    workflow answered alone is a row too (source: "grade"). learning.hold_disagree (3) disagreements in the newest
    learning.hold_window (10) rows of the revision's current promotion hold it, and the agent's next run asks one
    recompile with those disagreements as data; a second hold within learning.stop_window (100) served runs stops it
    ("stopped: the workflow disagreed with the agent twice"). The shadow is no row of the run list; GET /v2/runs/{run_id} reads it with audit_of, and its cost is the served run's learning cost. A capped run's shadow is
    capped at what the run's cap left, so the two never spend past it, and a shadow never waits on a person: one that
    would ends there, parked, never counted toward a hold. Only runs started over the API are audited, and only for an
    agent every tool of which only reads, so a shadow never writes a second time; the promotions read says why one is
    not (audits_off, e.g. "audits off: send_email can write") (#3061).

Breaking

  • DSL: step guards are removed: a node takes no guard field, and GUARD_SIGNALS, GUARD_FIELDS,
    GUARDED_NODE_KINDS, SELF_CONFIDENCE_KINDS, the guardStep dependency, the guard escalation kind, the
    $confidence channel and softEscalates are gone; a replay obeys every escalate (#3064).
  • Learning: a promotion record keeps workflow, digest, at, decided, reason, check, runs, inputs,
    replay_id and commit; source, replay, refit, checked, since, held_on and skipped_by are gone, and
    so are the queued and skipped decisions (#3064).
  • API: GET /v2/agents/{agent_id}/learning/loop returns { agent, completed_runs, compiles }: guards is gone
    (#3064).
  • API: POST .../learning/workflows/{name}/revisions/{digest}/replays takes inputs: "held" or a number from 1 to
    200, and replays the agent's own completed runs, not its graded inputs (#3064).
  • API: the learning cost series' replay is the serving check's numbers, with agreed, alone and agree_min
    (#3064).
  • Configuration: AGENTRUN_SERVE_LEARNING_GENERAL_THRESHOLD is removed with the generality pre-check on Jev: the
    grader reads every note (#3064).
  • API: the promotions read's serving entries gain state (serving, checking, held or stopped), check,
    audit, audits_off and not_auditable (#3061).
  • API: definition.learning takes six more numbers, audit_every, audit_every_later, audit_later_after,
    hold_window, hold_disagree and stop_window, each a whole number from 1 to 1000 with hold_disagree at most
    hold_window, else a 422 on definition.learning (#3061).
  • API: while a served run's shadow is queued or running, its cost.usd, cost.all_in_usd and learning cost read null
    (#3061).

Behaviour changes

  • The compile turn asks only for a new workflow or one revision of a held one (#3064). A hand-back, a wrong grade
    and the money rule's stop ask for no revision. A compile whose drafts all fail their checks is a compile too: it
    writes a hold whose reason names the failed check, a failed first compile earns the one recompile, and a failed
    recompile stops; nothing is asked again for that revision. No new compile is asked while a draft that passed its
    checks waits on its grade.
  • A check's numbers add up (#3061). Its outcomes add up to its n: a replay run never created by the check's
    deadline is failed, and the record's new check.unstarted counts those. A check none of whose runs was created
    reads failed on GET .../replays/{replay_id}. A check whose every input stopped at a write stops with the cause
    and spends no recompile.
  • A promotion hold says whose it is (#3061): a hold with audit is an audit's, one without it its check's. The
    graded hold is gone: an owner's grade of a served run is one more audit row.

Known issues

  • The Cloudflare relay fix in this release (#3072) is not the whole fix: the relay needs #3090 too, so redeploy it from
    beta.44 (or main) once that ships. Don't depend on the Clo...
Read more

AgentRun v0.1.0-beta.42

Pre-release

Choose a tag to compare

@claudio-michel claudio-michel released this 17 Nov 14:18
3b10f6f

AgentRun 0.1.0-beta.42

AgentRun is an open-source platform that supercharges your agents. It adds self-improvement, durable execution and a
control plane on top of your favorite agent harness. Your agents become smarter, more fault tolerant and use fewer
tokens with every run. This release is about learning you can check and computers you can watch. A learned workflow is
compiled once and promoted only when it agrees with the agent's own answers, and it compiles to a cascade that answers
from compact facts. An agent's desktop or phone can record a video of each run's screen, which the API serves and the
console exports, and a run's phone can carry real apps. Agents read the owner's calendar through the new
calendar_events tool, and a feed trigger on a JSON list keeps only the fields it names and fires again when an item's
date moves on. Computers gain boxd, Morph and Fly Machines providers, and E2B and Modal machines can dial the server.
The store does not change: SQLite keeps schema version 11 and Postgres version 16, so going back to beta.41 is changing
the image back on both. The launcher is @parcha/agentrun 0.4.10, the Python client parcha-agentrun is 0.3.10, and
the server image is ghcr.io/parcha-ai/agentrun-server:v0.1.0-beta.42 (linux/amd64 and linux/arm64).

No fresh store: beta.42 opens the data beta.41 left. Keep the same data folder and the same start command, and
change only the image to ghcr.io/parcha-ai/agentrun-server:v0.1.0-beta.42. Your agents, triggers, runs and settings
are all still there.

  • No store change. SQLite stays at schema version 11 and Postgres at 16 (0016_minted_tokens), with no migration
    and no new table or column. At each start the server keeps its own addresses in one settings row
    (mcp.server_own), which beta.41 ignores.
  • Going back is setting the image back to v0.1.0-beta.41, on SQLite and on Postgres alike: beta.41 opens the
    store beta.42 used, with every agent, trigger, run and setting in it, and no pg_dump restore is needed. What
    beta.41 does with what only beta.42 writes:
    • An agent whose learning is an object: beta.41 reads it back as saved and runs the agent, with learning off. It
      refuses to save a new definition of that agent (422 wrong_type on definition.learning, "true, false or
      "notes""): to edit it on beta.41, set learning: true, and set the object again once you are back on beta.42.
    • The calendar: beta.41 has no calendar routes (404 "no route /settings/calendar") and no calendar_events tool.
      The saved address stays sealed in the store, and beta.42 reads it again on return: there is nothing to save again.
    • A feed trigger on a JSON list with fields or updated: beta.41 keeps it on and shows both pointers, but uses
      neither. A new item fires with the whole item cut at 16 KB (item_truncated), and an item whose date moves on
      fires nothing. Back on beta.42, each item first seen on beta.41 starts one more run at the first poll, as
      update: true: a target that must act once per item should skip an update it has already handled.
    • Run recordings: beta.41's run read has no recordings, and GET /v2/runs/{run_id}/files/recordings/<computer>.mp4
      answers 404 "no such file". The files stay beside each run's folder, and beta.42 lists and serves them again on
      return.
  • Learned workflows are promoted by agreement with the agent's own answers, not by grades. To compile sooner or
    hold drafts to a stricter bar, set learning: { compile_after: 5, agree_min: 0.9 } on the agent. A client that reads
    definition.learning as a boolean or "notes" must also accept an object, and treat it as on.
  • The compile turn asks for no step guard and refuses a draft with one. Learned workflows already saved keep
    running as they are; a revision of one drops its guards.
  • A workflow agent's runs no longer look back on their own: give feedback (a grade with words, or a follow-up
    message) on the runs it should learn from. A client that read feedback: "revise" on a grade reads null for a
    served run now.

Highlights

  • Learned workflows are promoted once, by agreement with the agent's own answers. An agent's learning takes an
    object, { compile_after?, agree_min?, alone_min? }, which is on with those numbers set; each one left out is its
    default (20, 0.8, 0.7), and true is every default. The first compile is asked once the agent has compile_after
    completed runs of its own, no longer on a count of kept notes. A new revision's first claim replays it on the inputs
    of those runs and scores each against the agent's own recorded answer, not a grade: it is promoted (source: "check") when it answered at least alone_min of them alone and at least agree_min of those said what the agent
    said. Under either bar it is held, and the agent's next run asks one revision with the inputs it disagreed on; held
    again, it stops (check.stopped), the agent keeps its runs and nothing compiles again. A draft with nothing to check
    it on stops with a reason that starts "nothing to check it on". The promotion record carries check (the bar, n,
    agreed, alone, the runs read, skipped_tools, and on a hold the disagreements), later grades and refits don't
    move it, and a newer revision waits for a running check (#3032).
  • Compiled workflows take the cascade shape. The compile turn's worked example is the cascade a repeated job
    compiles to: a call step fetches the page, a fast-tier extract step copies compact facts from it, the answer step runs
    on the agent's model from those facts and its own draft alone and re-picks once, in a loop of 2, until its quotes pass
    quote_missing, and an escalate step hands back a second miss or a case the policy does not cover. A draft whose
    model step off the fast tier reads a fetched page (through its state map, or the whole state with no map) is
    refused in one line naming the step, and the quote check's re-pick asks for the compact state map where it read
    every page on the agent's model. In the DSL, a whole-string placeholder marked optional, "{draft?}", is null while
    its path is absent; an unmarked one still fails missing_interpolation. placeholderValue(state, path) and
    placeholdersOf(text) are exported for a host that checks what a step reads (#3025).
  • Run video. definition.computer.record: true (off by default) records an agent's desktop or phone from the
    claim's attach until the computer's release or the run's end, with or without a viewer, as
    recordings/<computer>.mp4 beside the run's work/: H.264 in fragmented MP4, at most 10 frames a second and 1280
    pixels on the long side, no audio. A park pauses it and the resumed run goes on in a new file. It never holds up the
    live view or the agent, and a cap (500 MB across a run's files, 2 hours), an encoder that stops or a screen that stops
    answering ends the recording with a line on the timeline, never the run. The video shows everything on the screen, a
    person's typing during a take-over and any secret included: pixels can't be redacted. A server without ffmpeg on its
    PATH refuses record: true at save, as does a computer that is not a desktop or phone (422 not_allowed) (#3047).
    The run read lists recordings (path, computer, seconds, bytes, finished), GET /v2/runs/{run_id}/files/recordings/<computer>.mp4 serves one as video/mp4 to whoever may read the run's files
    (?download=1 for an attachment), and the files route answers one byte range for every file, so a <video> can seek
    (features.files.range: true). A recording reaches the disk as it is made, a fragment every 2 seconds or so. The
    console's Screen tab says "Recording" while one is written and offers Export once it is finished (#3063).
  • A calendar for agents. An owner saves the server's one calendar by its secret iCal address (Google Calendar's
    "Secret address in iCal format", Outlook's ICS link, iCloud's public link), and the new host tool calendar_events {from?, to?} reads its events. The routes are GET, PUT and DELETE /v2/settings/calendar and POST /v2/settings/calendar/test, for the owner's signed-in session alone (the token is 403); the console's page comes
    next. PUT {url} takes https and reads webcal:// as https; plain http is taken only to a loopback name
    (localhost, 127.x.x.x, [::1]), which only a local install reads. The address is sealed in the store and is in no
    answer, event, log line, error or run input, with its secret token and any address it redirects to scrubbed too. The
    test answers in words ("Work: 214 events, time zone America/New_York, next: Standup, Mon Nov 17 09:30") and saves
    nothing. The tool answers {calendar, time_zone, from, to, count, truncated, events}, at most 200 events sorted by
    start, over now through 7 days unless told otherwise and 62 days at most. Repeating events are expanded in the
    window (RRULE, RDATE, EXDATE, moved and cancelled instances, RANGE=THISANDFUTURE), each event keeps its own time
    zone across a DST change, and a read's work budget (15,000 rule steps, 1 s) answers a calendar that needs more in
    words, never as a partial list. It runs on every harness, is allowed by default and not metered, and an event's words
    are untrusted, as a page's are. The fetch is held to the server's one address rule, an MCP server's: a private
    address only when its host is allowed in Settings → MCP servers, link-local and this machine never, loopback only on a
    local install and never at the server's own ports, every redirect checked again; 10 MB, 20 s, 5 redirects, a read
    reused for 5 minutes and then revalidated. A template's tools may name calendar_events, and a template eval case
    may say calendar: <file>.ics (#3012).
  • Real apps on a run's phone. The operator names APK files...
Read more

AgentRun v0.1.0-beta.41

Pre-release

Choose a tag to compare

@claudio-michel claudio-michel released this 16 Nov 21:06
fa4da5a

AgentRun 0.1.0-beta.41

AgentRun is an open-source platform that supercharges your agents. It adds self-improvement, durable execution and a
control plane on top of your favorite agent harness. Your agents become smarter, more fault tolerant and use fewer
tokens with every run. This release is about agents that watch the world for you. A feed trigger starts a run for each
new or updated item of an RSS, Atom or JSON feed, or a JSON list such as GitHub's pull requests, and polls, so nothing
outside has to reach the server. Settings → MCP servers adds the servers the free templates use in one click: Parallel Search,
Firecrawl, GitHub with a token, Linear and Notion, and a template that needs one of them links straight to it filled. A
Google-backed MCP server stays signed in, a run's learned workflow tool runs only the revision that serves, and a
SQLite server no longer fails a write StoreBusy when its own transaction lets go during the wait.
A run keeps the labels its caller gives it and GET /runs filters on them, the server takes a list of API tokens so one
rotates with no caller refused, and a message to a working claude-agent run steers the turn in flight. On Postgres the
store moves to version 16, so going back to beta.40 there is restoring the copy taken before the upgrade; on SQLite it
keeps version 11 and going back is changing the image back. The launcher is
@parcha/agentrun 0.4.9, the Python client parcha-agentrun is 0.3.9, and the server image is
ghcr.io/parcha-ai/agentrun-server:v0.1.0-beta.41 (linux/amd64 and linux/arm64).

No fresh store: beta.41 opens the data beta.40 left. Keep the same data folder and the same start command. On the
Docker image that is --data /data/b37 --listen 0.0.0.0 --port 7340 --drain-timeout 6s as before, and on Render the
Docker Command you set for beta.37 stays. Change only the image to ghcr.io/parcha-ai/agentrun-server:v0.1.0-beta.41.
The console keeps its login, and your agents, MCP servers, keys, sign-ins, email account and triggers are all still
there. Upgrade the server first, then the runners: a beta.41 runner opening a data folder its server has not opened
yet is refused ("Start the AgentRun server to add each run's labels before opening a runner") and changes nothing.

  • SQLite keeps schema version 11: the server adds the nullable runs.labels column and the minted_tokens table at
    its open, and every run started before reads as given no labels.
  • Postgres goes from version 14 to 16 at the server's start: 0015_run_labels (a nullable runs.labels column) and
    0016_minted_tokens (a new table). With the server and runners stopped, before the first beta.41 start, take
    pg_dump --schema="${AGENTRUN_STORE_SCHEMA:-agentrun}" <url> > dump.sql, in a shell where AGENTRUN_STORE_SCHEMA is
    what the server is given, if anything (the schema is agentrun when it is unset).
  • Going back. On SQLite, set the image back to v0.1.0-beta.40; the command stays. On Postgres there is no way back
    in place: beta.40 refuses a schema at version 16 ("set up by a later release than this one"). Going back is
    psql <url> -c "DROP SCHEMA \"${AGENTRUN_STORE_SCHEMA:-agentrun}\" CASCADE", then psql <url> < dump.sql with
    psql from the same Postgres release as pg_dump, and setting the image back, which drops everything done on
    beta.41 since.
  • Feed triggers and going back. beta.40 turns every feed trigger off at its start (source_unreadable, "this
    server has no feed source"), and it stays off when you return to beta.41: turn each on again (PATCH /v2/triggers/{id} {enabled: true}). It watches from that poll, so items that arrived meanwhile start no run.

Highlights

  • A feed trigger. {kind: "feed", urls, every_s?: 900, items?, id?, accept?} starts a run for each new or updated
    item in 1 to 20 feeds: RSS, Atom, JSON Feed, or a JSON list such as GitHub's pulls API, read at its items and id
    pointers. It starts watching at its first poll, which a create or turn-on runs at once (10 seconds at most), so the
    items already there start no run. An item fires once, and again with update: true when its updated time moves on;
    one poll starts 20 runs at most, oldest first, and reads are conditional on ETag and Last-Modified. A 410, or a 404
    three checks running, stops that URL, and the trigger turns itself off (source_unreadable) only when every URL has
    stopped. Reads are held to the MCP servers' address check (no private, link-local or own address, each of 5 redirects
    checked again), 20 s and 5 MB at most, and a feed that declares an entity in a DTD is refused. The run gets
    {id, link, title, published, updated, author, summary, categories, feed: {title, url}, update}, or
    {id, link, title, item, update} for a JSON list. Template packages may carry feed triggers, with urls from the
    owner's parameters, and a template eval case's feed: fixture serves fake feeds (#3005). The console makes and edits
    one: Triggers → New feed trigger takes 1 to 20 URLs, one a line, an interval, a JSON list's pointers and "Only when"
    conditions, and the trigger's page says its last check and what it starts from ("Watching 2 feeds from now: the 130
    items already there won't start runs.") (#3020).
  • Run labels. A run takes labels at its start (POST /agents/{agent_id}/runs, POST /runs): up to 16 of the
    caller's own key-value strings, served on every read, and GET /runs and GET /agents/{agent_id}/runs take
    label=<key>:<value> to list only the runs holding it. The server reads nothing else from them, so they are no place
    for a secret (#2214).
  • API tokens that rotate. AGENTRUN_TOKENS holds a list of id:secret entries, any of which opens every route the
    token opens, so a token rotates with no caller refused: add the new one, move the callers, remove the old one.
    AGENTRUN_TOKEN (or DIR/.token) keeps working as the one entry default. Each request's log line names the token's
    id, never its secret, and deploy/README.md gives the three steps (#2217).
  • Steer a Claude Agent run mid-turn. A message sent to a working claude-agent run is read at the model's next step,
    in the same turn, where it waited for the turn's end; the Timeline shows it after the tool call it arrived during
    (#2783).
  • Composio deletes clean up after themselves. Deleting a Composio server also removes what its save made in your
    Composio account (the connected account its link started and the auth config it made), keeps what another saved server
    still uses and never touches what was there before, and says what it removed and kept (#3015).
  • Learned workflows re-pick a quote miss. A learned workflow whose answer quotes the pages it fetched writes its
    answer once more on a quote miss before it hands back to the agent; on the test set, re-picking kept 26 of 31 misses at
    about half the cost of handing every one back (#3016).
  • MCP presets. Settings → MCP servers offers five servers in one click, the ones the free templates use: Parallel
    Search (https://mcp.parallel.ai/mcp, no credential), Firecrawl (https://mcp.firecrawl.dev/v2/mcp, free and rate
    limited without a key), GitHub with a fine-grained token (a Read-only switch picks .../mcp/readonly), and Linear and
    Notion with Sign in. Each fills the name, address, credential and toolkit; #/settings/mcp?add=<name>&preset=<id> opens
    the form filled (#2999). Applying a template whose url MCP need is one of these toolkits links to that preset filled
    (#3003). When the keyless web search is rate-limited, its words name the free Parallel Search server too, and the
    Parallel preset uses the address Parallel's docs give (search.parallel.ai/mcp is its legacy one) (#3006).
  • A Google MCP server stays signed in. A sign-in whose authorization endpoint is on accounts.google.com asks for
    offline access (access_type=offline, prompt=consent), so it gets a refresh token; other servers' sign-ins are
    unchanged (#2997).
  • The learned workflow tool runs only what serves. A run's learned_workflow tool calls a workflow's champion, the
    revision promoted last, never one that is replaying, queued, held or undecided. Before, a run its workflow did not serve
    first could be handed the folder's newest revision, so an unpromoted draft could answer it (#3008).
  • SQLite writes that wait land. A begin, write or statement whose wait for the write lock ran out while a transaction
    of the same process held it no longer fails StoreBusy when that transaction's commit is read before the busy answer: it
    waits on and lands (#3002).
  • Computer vendors. Vendors that build images their own way get two more prepareImage paths: a push to the vendor's
    registry tagged agentrun-box:<hash>, or box/Dockerfile as the build context on the vendor's side (#3000). Output that
    comes as server-sent events reaches framedExec with no reader of its own (#2996). Modal's kill() ends the process
    tree in the machine and Daytona's exec runs on framedExec (#3001), the exec pre-check stays under Modal's 64 KiB
    argv cap (#3009), and a vendor's deleted machine reads undefined (#2992). A vendor machine with no exec can dial the
    server instead, with a token minted for it alone, and fetch the server's own computerd build (#3013, #3019). A
    self-hosted Daytona target with an Archil egress relay (DAYTONA_ARCHIL_EGRESS) takes Archil mounts again (#3021).
    packages/computer/SCORECARD.md reads 25 sandbox vendors against the provider contract (#2994).

Breaking

  • The machine-host label and lifetime mechanisms are cut back to what the reference providers use (#2998,
    @parcha/agentrun-computer). HostFacts.backstop, the Core case provider.backstop, HostFacts.idleMs and the host
    member keepalive are gone, and the shared adapter packs labels itself. A host that declare...
Read more

AgentRun v0.1.0-beta.40

Pre-release

Choose a tag to compare

@claudio-michel claudio-michel released this 16 Nov 11:30
bb7fb3e

AgentRun 0.1.0-beta.40

AgentRun is an open-source platform that supercharges your agents. It adds self-improvement, durable execution and a
control plane on top of your favorite agent harness. Your agents become smarter, more fault tolerant and use fewer
tokens with every run. This release is about templates that set themselves up, and runners that hold up at scale. A
template package's Composio trigger names the package's own Composio need and is made on the server that need resolves
to, so a package carries its Composio events again, and a template whose setup is only parameters is applied from its own
screen with Apply. On OpenRouter, a model that must reason is never sent reasoning off (ERNIE 5.5 Flash Preview, free, which
OpenRouter refused on pi for it), and a pi run's effort reaches a Chat Completions model such as gpt-6.1-sol. On Postgres, a runner renews
its claims and claims a batch of runs in a few statements whatever their count, and a store call waits for a busy pool's
connection up to a write's deadline, so a runner of 300 runs on a database a few milliseconds away no longer loses every
claim at once. The inbox from beta.39 gets its follow-up: email_send asks a person past five sends
in a run and before it writes outside the email's thread, and an email trigger starts watching at its first check. A
npx @parcha/agentrun start that fails now always says why: the step, the exit code or signal, the server's last lines
and a start log.
The store does not change: change only the image, and going back to beta.39 is changing it back. The launcher is
@parcha/agentrun 0.4.8, the Python client parcha-agentrun is 0.3.8, and the server image is
ghcr.io/parcha-ai/agentrun-server:v0.1.0-beta.40 (linux/amd64 and linux/arm64).

No fresh store: beta.40 opens the data beta.39 left, and beta.39 opens what beta.40 leaves. The SQLite schema
stays at version 11 and Postgres at version 14: this release adds no migration and no column. Keep the same data folder
and the same start command. On the Docker image that is --data /data/b37 --listen 0.0.0.0 --port 7340 --drain-timeout 6s as before, and on Render the Docker Command you set for beta.37 stays. Change only the image to
ghcr.io/parcha-ai/agentrun-server:v0.1.0-beta.40. The console keeps its login, and your agents, MCP servers, keys,
sign-ins, email account and triggers are all still there. Upgrade the server first, then the runners, as before.

  • Going back. Set the image back to v0.1.0-beta.39; the command stays and there is nothing to restore. A copy of
    the data folder (or pg_dump --schema=agentrun <url> on Postgres) before you upgrade is still good practice.
  • Nothing else under the store changed shape.

Highlights

  • Composio triggers in template packages. A package's composio trigger names its own Composio need by its toolkit
    (source.server: github for the need {source: composio, toolkit: github, required: true}), and Apply makes the
    trigger on the saved Composio server that need resolves to: the one candidate, or the owner's pick. Its config may
    hold ${parameters.<name>}, so one package watches the owner's repository. A trigger this server can't set up yet (no
    public URL, no connected account) is skipped with a not_set_up_here warning and the agent stands (#2974).
  • Apply for a template that needs only parameters. A template with no MCP tool and no key to set up is applied from
    its own screen: Apply is the main action there and Configure on its card, and "Set it up with an agent" is the second
    way. One that reads mail waits for a mailbox saved under Settings → Email and links there (#2981).
  • OpenRouter reasoning. A model OpenRouter marks as one that must reason is registered so pi never sends it
    reasoning off: ERNIE 5.5 Flash Preview (free) answered every request with "Reasoning is mandatory for this endpoint and
    cannot be disabled." and is now sent no reasoning off, so it reasons at OpenRouter's default effort for it. Ling 3.2 Flash (free), which may stop
    reasoning, still runs with thinking off (#2984). A pi run's effort now reaches an OpenRouter model that speaks Chat
    Completions, openrouter/openai/gpt-6.1-sol (pi's default on an OpenRouter key) included, as reasoning: { effort }
    mapped by the model's catalog entry (#2985).
  • Postgres runners at scale. A runner's renew of the claims it holds, and its claim of a batch of runs, are a few
    statements whatever the count: a runner holding 300 runs no longer renews in about 600 round trips with every row held,
    which on a database a few milliseconds away outlasted the claim deadline and lost every claim at once (#2971). A store
    call that finds every pool connection in use waits up to a write's deadline (10 s, poolWaitMs) instead of the 4 s
    connect timeout, so a busy runner's runs no longer fail for good with "no connection to the store's Postgres" while
    the database answers; a database that does not answer still fails fast, in words that say so (#2976).
  • Email follow-up. email_send asks a person in two more cases, even when it is set to allow: after a run has sent
    5 emails, each further send asks ("this run has sent N emails"), which stops two auto-responders from answering each
    other without end; and on a run an email started, a send to anyone outside that email's thread asks, naming them. The
    approval says why ("Asks because …"). An email trigger starts watching at its first check, which runs at once when the
    trigger is made, turned on again or edited, and a create or turn-on answers once that check is done (10 seconds at
    most), with last_check in its answer (#2977).
  • A launcher start that says why. When npx @parcha/agentrun can't start the server it says, on stderr, the step that
    failed, how the server ended (its exit code; the signal, with a hint when a SIGKILL nobody sent points to the system
    running out of memory; still running after 60 s, then stopped; or never started, with the error), the server's last
    lines on stderr and stdout, and start.log in the data folder, which holds everything the server wrote in that start.
    A server that ignores the SIGTERM after 60 s gets a SIGKILL instead of leaving the command waiting forever (#2980).
  • Learning keeps its replays. A running replay finishes: a revision that arrives meanwhile is queued, and only the
    newest queued one replays next (#2970). The Learning tab's after figure counts only runs a learned workflow served, and
    says why it is empty when it is; on a 480-run agent the cost read takes 7 store calls instead of 1,549 (#2975).
  • Judge requests that fit Jev. A Jev request that may not fit Jev's context goes in its long-context mode, and one
    that may not fit that either has its longest state values cut, each marked [cut], where Jev refused the whole request
    and failed the workflow step (#2969).
  • Computer vendors. The shared machine-host adapter takes vendors that keep no labels, splits exec into the calls a
    vendor has (framedExec), sets a backstop on a vendor's own delete timer and keeps a vendor's idle timer from ending a
    quiet computer; the conformance kit prints what a machine offers and runs on a plan that keeps few machines at once
    (#2973, #2979, #2982, #2967, #2978).
  • A console that lines up. Settings pages share one layout, forms use the width they have, the Playground's code
    panel folds, and a keyboard or a screen reader gets through every page (#2675).

Breaking

  • A running replay is never cancelled (#2970). decided: "superseded" and superseded_by are gone from a learned
    workflow's promotion records and from a replay read's decided: a revision that arrives while another replays is
    queued, and one queued before a newer one is skipped, with skipped_by naming the newer revision. A client that
    read superseded reads queued, skipped and skipped_by. Both generated clients change with it.
  • A hosted vendor's exec carries text (#2979). It has to keep UTF-8 text intact both ways, where it had to carry every
    byte value; the daemon's upload through exec goes as base64 text. In the conformance kit the pre-check's
    stdout-bytes and stdin-bytes are stdout-text and stdin-text, bytesProblem is textProblem, and runToExit's
    stdin is an iterable of pieces, each whole UTF-8 text.
  • The box Dockerfile takes no build arguments (#2989). Its build is box/install.sh, with the archil client's version
    and sums pinned there.

Behaviour changes

  • A template package's Composio trigger must name a required Composio need of the package (#2974): one that names no
    source: composio need is refused when the package is read (422 at import), and the need it names is
    required: true. A trigger made with POST /v2/triggers is unchanged.
  • A pi run's effort costs what it asks for on OpenRouter (#2985): a run that sets an effort on an OpenRouter Chat
    Completions model may cost more and take longer than it did, since the effort was dropped before; a run with no effort
    set sends what it sent before.
  • The learning cost read's after side is served runs only (#2975). A replay run, and a run by hand after the takeover,
    no longer move summary.after, times_cheaper, withheld or hand_backs; the new summary.after_state says why
    after is null (no_served_runs or cost_unknown), else priced.
  • A Jev judge request over the default context runs in the slower long-context mode instead of failing (#2969); pass
    longContext: false to cut to the default context instead. A decision receipt's state is the state its provider sent,
    with state_cut naming each value cut; state_sha256 is still the digest of the state asked.
  • apps.launch of a url in an app that already runs fails unsupported when the launch shows a dialog of its own
    (Firefox's "already running" box), naming the dialog and ...
Read more

AgentRun v0.1.0-beta.39

Pre-release

Choose a tag to compare

@claudio-michel claudio-michel released this 16 Nov 07:12
5327205

AgentRun 0.1.0-beta.39

AgentRun is an open-source platform that supercharges your agents. It adds self-improvement, durable execution and a
control plane on top of your favorite agent harness. Your agents become smarter, more fault tolerant and use fewer
tokens with every run. This release is about an inbox assistant that runs on your own machine, and about starting with
no model key. The server reads and sends mail through one account of yours, an email trigger starts a run on each new
message, and Settings → Email sets the account up. npx @parcha/agentrun now ends its first screen with Continue with
ChatGPT: Codex and pi run on your ChatGPT plan with no key saved. A run's cap is never passed (one worst-case mode, and
cap_mode is gone), a free model costs a known $0 and stops at a request limit, an OpenRouter run books what OpenRouter
charged, and a run that parks for you keeps its desktop, phone or sandbox for 10 minutes. Mode 2 now starts on Agent37,
Modal and E2B from AgentRun's public box image. Existing Claude Code and Codex setups connect without copying their
configuration, and the Learning tab replays a held workflow and grades a run. There is no fresh store this time: the
SQLite store stays at version 11 and Postgres migrates itself. The launcher is @parcha/agentrun 0.4.7, the Python
client parcha-agentrun is 0.3.7, and the server image is ghcr.io/parcha-ai/agentrun-server:v0.1.0-beta.39
(linux/amd64 and linux/arm64).

No fresh store: beta.39 opens the data beta.38 left. The SQLite schema is still version 11, and Postgres goes from
11 to 14 (migrations 0012, 0013 and 0014). Keep the same data folder and the same start command. On the Docker image
that is --data /data/b37 --listen 0.0.0.0 --port 7340 --drain-timeout 6s as before, and on Render the Docker Command
you set for beta.37 stays. Change only the image to ghcr.io/parcha-ai/agentrun-server:v0.1.0-beta.39. The console
keeps its login, and your agents, MCP servers, keys and sign-ins are all still there.

  • SQLite. The server adds three columns when it opens your folder, so there is nothing to run: revisions.monid_pin
    (an agent revision's monid pin, #2863), settings.connector_id with an index on it (#2839), and runs.cost_upper_bound
    (#2911; every run that ended before reads 0). Start the server first: a runner started on a folder the server has not
    yet opened refuses with "Start the AgentRun server ... before opening a runner". Copy the data folder before you
    upgrade.
    beta.38 still opens the folder afterwards (it checks the schema version only, 11, and its writes name
    their columns, so the new ones take their defaults). To go back, restore the copy and set the image back to
    v0.1.0-beta.38; the command stays. Two things beta.38 does not read: an agent revision saved on beta.39 with a
    monid grant keeps its pin in revisions.monid_pin, where beta.38 looks in the revision's body, so its runs are
    offered no monid endpoint; and a trigger of a kind beta.39 added (composio, email) is one beta.38 does not know:
    delete such triggers before you go back.
  • Postgres. Migrations 0012_revision_monid_pin.sql, 0013_native_command_owner.sql and
    0014_run_cost_upper_bound.sql run when the server starts, and the server moves the schema to version 14. Going
    back does not work without a backup:
    beta.38 refuses a schema at version 12 or later, with the Postgres schema agentrun is schema version 14, set up by a later release than this one (this release knows version 11). Run that release or a later one. Take a backup of the store's schema before you upgrade (for example pg_dump --schema=agentrun <url>, with your own schema name if you set one), and to go back restore it and run beta.38 on the
    restored data. Start the server first: a beta.39 runner started on a schema the server has not yet migrated refuses
    to start, and so does a beta.38 runner on a migrated one, so upgrade the server, then the runners.
  • Two things to do after the upgrade. An agent saved on beta.38 with a monid grant has its pin in its revision's
    body; beta.39 reads it from the new column and does not copy it across, so that agent's runs are offered no monid
    endpoint, and none runs unheld, until you save the agent again (#2863). A webhook trigger made the old way for
    Composio's events (signature: "composio") stops firing: delete it and make a Composio trigger for the same event
    from Triggers → New app trigger (#2961).
  • Nothing else under the store changed shape.

Highlights

  • A local inbox.
    • The server reads and sends mail through one account of yours, over IMAP and SMTP with an app password, sealed like
      every other secret (GET, PUT and DELETE /v2/settings/email, presets for Gmail, Fastmail and iCloud or servers
      of your own; Outlook is refused for now, as it needs a Microsoft sign-in). POST /v2/settings/email/test signs in
      to both servers and saves and sends nothing.
    • An email trigger ({kind: "email", mailbox?, every_s?, accept?}) starts a run for each new message its accept
      takes, from the moment the trigger is made (mail from before starts nothing, and that is said), and shows its last
      check. It turns itself off (sign_in_refused) after the mail server refuses its sign-in three times in a row. An
      edit of its accept or every_s while its start is being taken keeps that start (#2963).
    • Five tools, on every harness: email_search, email_read, email_draft, email_send and email_file.
      email_send asks a person by default and its approval shows who it goes to and what it says; email_file files a
      message under a Gmail label or moves it to a folder and never deletes one. A run an email started reads and files
      only that email's thread, and only the messages its sender took part in, unless the agent's scope: "mailbox"
      setting widens it. Each call reads as one line on the timeline, with no message body in it (#2874).
    • Settings → Email sets the account up: Gmail, Fastmail, iCloud or your own servers, where each app password comes
      from, a Test that signs in to both servers and sends nothing, Save (the password is never shown again) and Remove
      (#2912).
    • A template's eval can run an inbox agent on a fake mailbox seeded from a fixture (email: fixtures/mailbox.json in a
      case), never real mail: each run gets a fresh account per layout (Gmail labels or folders), starts as the package's
      email trigger would, and graders see each email call and the mailbox after the run, with a mailbox grader for
      where a message ended up. eval-template --on-data DIR runs the eval on a stopped server's data folder, so a
      package's cases are measured on the owner's ChatGPT plan with every fake still bound (#2923).
  • No model key needed to start. Continue with ChatGPT, on the console's first screen and in Settings → Model keys,
    runs Codex and pi on your ChatGPT plan. The sign-in is the person's who runs the server, finishes by itself on the same
    computer or by pasting the sign-in tab's address on a server elsewhere, renews once across the server and every runner,
    and signing out revokes every token it leaves behind. A run on the plan says its tokens and "Using ChatGPT plan", never
    $0.00 or unknown, and a capped run on a plan model is admitted. npx, Render, Docker and Compose all start with no
    key and end the same way (#2862, #2865, #2866, #2872).
  • A cap is never passed. Every model request is held at its worst case, its whole input priced uncached, so a cache
    miss can no longer take a run past max_cost_usd. The expected mode is gone with the cap_mode setting. A request's
    answer is clamped to what the cap has left, parallel steps near the cap wait for each other instead of parking, and a
    capped OpenAI-model run counts its input with a local o200k_base count, with no wait on OpenAI's count request
    (#2871, #2920, #2935, #2947, #2950, #2956).
  • Free models. A run whose every request went to a free model (an OpenRouter :free model, say) costs a known $0
    and says so; the model picker marks free models and can show only them; a run on one stops at 60 requests, and is
    told three requests before. Two free OpenRouter models that pi's catalog lacks are listed at $0 (#2879, #2883, #2900,
    #2917, #2929).
  • Mode 2 on every vendor. An Archil run folder starts on Agent37 and Modal in any account from AgentRun's public box
    image, and on E2B from a public template. Hosted computers take network open and allowlists through an egress
    proxy, so a hosted desktop's browser and a sandbox's pip, npm and git reach the web. E2B's system paths are
    hardened against the computer's user (#2832, #2861, #2888, #2933, #2889).
  • A park keeps the computer. A desktop, phone or sandbox run that parks for a person keeps its computer for 10
    minutes; an answer inside that time resumes on the same machine. A run that does resume on a new computer is told so,
    and its live view says what it waits for instead of "ended" (#2931, #2936, #2906, #2915, #2926).
  • One cost figure. An ended run's cost is read from its booking, and a request cut with no answer under a cap is
    booked at what the cap held, shown as "at most $0.97". An OpenRouter run books what OpenRouter charged, and a
    provider's error inside a 200 stream is booked by what it reported (#2911, #2901).
  • Connect the Claude Code and Codex you already run. A local setup connects without copying its configuration or
    credentials, runs through an outbound worker on another machine if you choose, imports selected history with consent,
    and can be observed read-only. The client wraps existing Claude Agent SDK queries and Codex SDK clients to supply
    checked notes and skills (#2837, #2838, #2839, #2840, #2841, #2842, #2843, #2844).
  • **Learning you can replay and gr...
Read more

AgentRun v0.1.0-beta.38

Pre-release

Choose a tag to compare

@claudio-michel claudio-michel released this 14 Nov 23:10
d10f005

AgentRun 0.1.0-beta.38

AgentRun is an open-source platform that supercharges your agents. It adds self-improvement, durable execution and a
control plane on top of your favorite agent harness. Your agents become smarter, more fault tolerant and use fewer
tokens with every run. This release is about tools, templates and what an agent learns. Every harness (pi, Claude Code,
Codex, OpenCode) now calls MCP tools through one gate, finds tools with tools_search and runs scripts with codemode.
A template package installs from a GitHub address, names where its tools come from, takes typed input and answers in a
schema. A learning agent compiles its job into a learned workflow, runs it first, and serves a new version only after a
replay on graded runs. A Linux desktop opens apps and reads plainly in the timeline, and a program inside a computer can
no longer reach the desktop's session bus. A capped Codex, OpenCode or pi run pauses less often. There is no fresh store
this time: the SQLite store stays at version 11 and Postgres migrates itself. The launcher is @parcha/agentrun 0.4.6,
the Python client parcha-agentrun is 0.3.6, and the server image is
ghcr.io/parcha-ai/agentrun-server:v0.1.0-beta.38 (linux/amd64 and linux/arm64).

No fresh store: beta.38 opens the data beta.37 left. The SQLite schema is still version 11, and Postgres goes from
9 to 11 (migrations 0010 and 0011). Keep the same data folder and the same start command. On the Docker image that is
--data /data/b37 --listen 0.0.0.0 --port 7340 --drain-timeout 6s as before, and on Render the Docker Command you set
for beta.37 stays. Change only the image to ghcr.io/parcha-ai/agentrun-server:v0.1.0-beta.38. The console keeps its
login, and your agents, MCP servers, keys and sign-ins are all still there.

  • SQLite. Two changes, both made by the server when it opens your folder, so there is nothing to run: a new table,
    imported_templates (templates installed from GitHub, #2728), and an agent revision's MCP pin in a new column,
    revisions.mcp_pin, in place of the per-run pin table mcp_pins, which is dropped (#2719). Copy the data folder
    before you upgrade.
    beta.37 still opens the folder afterwards (it checks the schema version only, 11), but it writes
    each run's MCP pin to mcp_pins at the run's first claim, so a run that grants an MCP tool fails on beta.37 once
    beta.38 has dropped that table. To go back, restore the copy and set the image back to v0.1.0-beta.37; the command
    stays.
  • Postgres. Migrations 0010_imported_templates.sql and 0011_revision_mcp_pin.sql run when the server starts,
    and the server moves the schema to version 11. Going back does not work without a backup: beta.37 refuses a
    schema at version 11, with the Postgres schema agentrun is schema version 11, set up by a later release than this one (this release knows version 9). Run that release or a later one. Take a backup of the store's schema before
    you upgrade
    (for example pg_dump --schema=agentrun <url>, with your own schema name if you set one), and to go
    back restore it and run beta.37 on the restored data. Start the server first: a beta.38 runner started on a schema
    the server has not yet migrated refuses to start, and so does a beta.37 runner on a migrated one, so upgrade the
    server, then the runners.
  • Nothing else under the store changed shape. Agents you saved on beta.38 may carry fields beta.37 does not know
    (input_schema, a computer's surface and exec, a template record); beta.37 reads past them.

Highlights

  • One tool plane on every harness.
    • A run's MCP tools are host tools on every harness: each call passes the run's one tool gate, the runner calls the
      server with the credential and books it, and OpenCode now runs MCP tools too (#2722).
    • Every harness offers tools_search (find a tool by what it does), tools_call (run one by name) and codemode (a
      JavaScript script over the run's tools), each gated, recorded and booked as the tool's own call (#2749). Past 20
      catalog tools (MCP and monid) a run defers them behind search, and each of the three has a setting you can deny
      (#2759).
    • On pi, a script's or tools_call's nested calls show in the timeline as on the other harnesses (#2767).
    • One grammar for tool names, one MCP scrubber, cap and client, and grant_problems served on a saved server say why
      a tool can't be granted (#2690, #2738).
  • Templates from GitHub. Install a template package from github:<owner>/<repo>[/<path>], pinned to a commit, with
    an "Add from URL" box on Templates, agentrun template install on the CLI and a page that shows the publisher, the
    commit and every file before anything is stored (#2728). A template's MCP needs now name where their tools come from
    (Composio, GitHub or a URL), and apply maps each need to the saved server that matches (#2732). Apply grants only the
    tools you tick (#2718). The install and Apply screens show each run input, eval case and tool reason (#2789).
  • Typed run input. An agentic agent can take a JSON Schema input (definition.input_schema); every path that starts
    a run checks it, and the console draws the run form from it (#2731). A template parameter is an input in the same
    grammar (#2775), and a list parameter fills a schedule's typed input (#2733).
  • An answer that meets its schema. An agent with an output_schema is told the schema on every harness, is asked
    once more when its answer misses it, and the run serves output_error if it still does; the console's Report reads
    the structured answer (#2725).
  • Learning that compiles and proves itself.
    • A learning agent writes its whole job as a learned workflow in a compile turn, with a record of each attempt in
      GET /runs/{id}/learning (#2641).
    • A run starts on a fitting learned workflow before the agent's own model takes a turn, and a money rule asks for a
      new version when the workflow costs more than the agent by hand (#2603).
    • A workflow step can carry a guard that hands the job back below a threshold (#2639).
    • A new version serves first only after a replay on the agent's graded runs, with thresholds refit from them (#2644).
    • The console's Learning tab walks through the loop: a five-stage strip says what is learned and what happens next, and
      the cost chart flags each new version, promotion, hold and refit on the run it first affected (#2654).
  • A Linux desktop that opens apps (#2727, #2735). computer.apps lists, opens and closes apps on E2B and Agent37
    desktops, with a window manager so they are framed and focused, and a Mac and a Linux desktop read the same way.
  • A run on a computer reads plainly. The timeline says what the agent did ("Pressed “Display”", "Typed “dark”"), one
    voice in the row, the call list and a Mac movie, with a code-mode script's calls on its own row (#2729, #2762,
    #2747). The Screen tab reads sooner and has one Take over (#2730, #2745, #2736).
  • Computer isolation. A program running inside an E2B or Agent37 computer can no longer reach the desktop's
    accessibility bus or session bus (#2780, #2787, #2790, with the check in #2723). Nothing about what a computer can do
    for the agent changes: nsenter and rootless podman still work inside a computer.
  • Caps, tighter. A capped Codex, OpenCode or pi (on OpenAI's Responses) run's next-step estimate is closer to its
    real input, so it pauses for a raise later and less often (#2772). The wrap-up note, the reserve and admission price a
    warm request alike, so a capped Codex or Claude Code run is no longer told to finish with most of its cap left
    (#2786).
  • ask_person on Claude Code and Codex (#2743): a Claude Code or Codex agent can ask you a question mid-run. The run
    parks waiting for your reply, and your answer resumes it.

Before you upgrade

  • A gateway must serve /v1/messages for Claude (#2799). With AGENT_MODEL_BASE_URL set, pi now sends a Claude model
    to <base>/v1/messages (as LiteLLM's proxy and OpenRouter serve it) instead of /v1/responses. A gateway that serves
    only Responses fails those runs. If you set AGENT_MODEL_PRICE for a Claude model, give it the fourth number, the
    cache-write price (Anthropic's is 1.25 times input): with three numbers, a cache write is booked at the input price.
  • A pinned tool takes only its listed arguments (#2798). A call of an MCP tool that has a pin, in the agent's settings
    or the server's, is refused when it carries a top-level argument the tool's listing does not declare under properties
    (and is not pinned), and the model reads which one. A pin that relied on a server's undeclared alias (Slack's
    channel_id, Gmail's to) now fails that call: use the listed name, or drop the pin. Tools with no pin are unchanged.
  • A label goes with the grade (#2648): a client that sent a grader's label as a follow-up message
    (POST /runs/{id}/messages) sends it as the grade's label (PUT /runs/{id}/grade) instead.
  • monid is granted per endpoint (#2765). monid.discover, monid.inspect and monid.run are gone: an agent that
    grants one is refused at its save (422 not_an_option). Grant the endpoints it calls instead, monid:<provider>/<endpoint>
    (say monid:apollo/people/match) or monid:<provider>/* (at most 50), with a monid key saved in Settings → Tool keys.
    Each is pinned at the save with its description, input schema and price, and is one tool of its own on every
    harness. An endpoint monid prices by usage can't be granted (no hold could keep the cap), and a workflow can't bind a
    monid endpoint yet.
  • An agent's MCP tools are pinned when it is saved (#2719), on its revision, not at each run's first claim. Every run
    of that revision calls the tools as the server listed them at the save, with their prices.
    • A save (a create, a definition PU...
Read more