Skip to content

AgentRun v0.1.0-beta.44

Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 18 Nov 01:12
· 224 commits to main since this release
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 it read it; one changed or deleted meanwhile is left for the next start, with nothing sealed left behind for it. It runs no VACUUM while serving: the log says store_scrub_not_done with reason=deferred, and the next start's scrub finishes before it serves. When Composio can't be reached, it logs composio_config_schemas_unread once with a code and tries again at the next start. The start doesn't wait for this.
    • A field named sig is now sealed.
  • A Composio trigger's config field named like a credential is now sealed when the trigger is saved. This covers names like developer_api_key, api_key, client_secret, access_token and password: any field where a word of the name is secret, password, passwd, passphrase, token, credential, apikey, authorization, bearer or cookie, or where the last word is key, and the value is a string. The value is kept in the composio source's sealed settings, next to the subscription's secret. Composio still receives it when the server creates the trigger instance. Every trigger answer (create, GET, list, PATCH, template apply) shows "[sealed]" in place of the value and names the field in the source's new read-only sealed_config.

    • A create whose config holds such a value below its top level (inside an object or a list) is refused with a 422 that names the field. Composio's trigger configs are flat.
    • A PATCH that leaves a sealed field out, or sends "[sealed]", keeps the value. Sending a different value is a config change and is refused, as any config change to a composio trigger already is. To change a key, delete the trigger and make a new one; the refusal says so.
    • Deleting the trigger retires its sealed values into a sealed row until the runs that saw them end. A trigger saved before this release with such a value in plain text is answered masked at once, at any depth, and sealed at the next start; its Composio instance is not changed. On SQLite the store's files keep no copy of the old row after that rewrite, including copies that earlier updates of the row left in free space. If that cleanup can't finish (another connection holds the database's log), the log says store_scrub_not_done and the next start finishes it. The log names the trigger and the field, never the value.
    • The events list (GET /v2/settings/mcp-servers/{name}/composio/events) names each event's sealed fields under sealed, and the console's form takes those as password inputs. A trigger's page shows them as sealed.
    • When a call to Composio involves a trigger's sealed value, a refusal is answered and logged in the server's own words (the step and the HTTP status), never Composio's. On other calls, Composio's words still pass on with the API key removed, including its JSON-escaped and percent-encoded forms.
    • An Idempotency-Key's record in the data directory now keeps an HMAC of the request body under a key derived from the server's seal key, not the body itself, and keeps a trigger create's answer masked. Other answers, such as a run's input, replay as they were. Records an older server wrote (kept for up to a day) are rewritten at start, and the log says how many.
  • A phone's error and observation texts name apps by their labels, not package ids. "org.wikipedia has no window on the screen (... of com.android.systemui ...)" now reads "Wikipedia has no window on the screen (... of System UI ...)". phoned reads the label through PackageManager (launcher app or not); where the phone gives none, the text keeps the id once, in parentheses after the words ("the app (org.example)"). Call arguments and structured fields keep package ids. The apps.launch refusals (not installed, no activity, refused start, force-stop) name the app the same way.

  • A learned workflow this release's DSL refuses is held with the DSL's reason and recompiled once; it no longer reads serving while every run hands back.

    • The first run a refused revision serves hands back as before, and writes one promotion hold for that digest: reason "this release's workflow DSL refuses it: at : ...", cut of the host's secrets, with neither check nor audit. Concurrent and later runs write nothing more; the agent takes them. The promotions read says held, and the agent's next run asks the one recompile with that reason; a recompile that is held again stops.
    • Shadow audits draw only runs the workflow answered alone (path workflow). A run it handed back is never drawn and never counts as a served run for learning.audit_later_after, learning.stop_window or not_auditable.
  • The Cloudflare relay's computer object sets the container's inactivity timeout when it starts, for a container that is running and not ended, so a relay redeploy no longer leaves the container without one until the next hourly alarm.

  • AgentRun Server binds its port and prints Starting <url>/ before it loads the rest of itself, so a start on a slow or loaded disk names its address in seconds, not minutes. Until it is ready it answers that it is warming: GET /v2/health is 503 with status: "warming" and checks.store: "opening", the API answers 503 unavailable with a Retry-After, and a browser gets a page that reloads itself. On a cold disk, a request sent while the server's modules load is answered once they have. Then the banner prints as before, and its Open line still means ready.
    npx @parcha/agentrun takes the Starting line as the server listening: it names the address on stderr at once, and its start bound (60 s, or AGENTRUN_START_TIMEOUT_MS) no longer stops a server that is up and still loading. A start that does pass the bound says so and names AGENTRUN_START_TIMEOUT_MS.
    A port already taken when the server starts is left to the start's own wait, as before, so a restart still waits for the server it replaces and takes its port.

  • computerd's search for the unix sockets a tool can connect to no longer goes into mounts of proc, sysfs or the kernel's other views (cgroup, debugfs, tracefs, securityfs, bpf, configfs, pstore, binfmt_misc, fusectl, autofs), where no socket can be a file. It finds them in /proc/self/mountinfo, and still walks any other mount below one, so a tmpfs mounted under proc is searched. Cloudflare's container runtime mounts proc and sysfs under /run/cloudchamber, about 58,000 entries, which filled the 50,000-entry budget of the /run walk, so isolation.vendor-agent failed on Cloudflare with no socket left unsearched. The probe's sockets report has a new skipped list naming each mount not gone into with its filesystem, and the conformance case shows it.

  • Anyone with write access can cut a release: the release workflow checks what a person used to. Its gate job refuses a tag that is not newer than npm's latest for @parcha/agentrun-serve and the newest GitHub release (semver order, beta.9 < beta.10 < 0.1.0), or that is not the version the manifests at the tag say, and requires every check main's ruleset requires (verify and lean, not verify alone) to have passed on the push run of exactly the tagged commit. After every publish job passes, a new github-release job publishes the release on the existing tag with the version's folded CHANGELOG.md section and the install lines as its notes, and a slack job posts it to the channel in the repository variable SLACK_RELEASES_CHANNEL with the star notifications' bot token; Slack never fails a release. Approval stays the npm-release environment's required reviewers.

    • A website job then opens the website's import pull request (content: import AgentRun <tag>, branch release/<tag>-content) with the website App's token (WEBSITE_APP_ID, WEBSITE_APP_PRIVATE_KEY), running the website's own scripts/import-content.py against the tag. Without the App, or with nothing to import, it is a notice; it never fails a release.
    • A release that stopped partway is finished by re-running its failed jobs: a new dispatch of a tag npm already has stops at the gate.
  • PROVIDERS.md's Fly section says how to name the Fly app the machines live in. Fly app names are global, so use agentrun-computers-<org slug> (the API call and the fly apps create line are given). It also says that Fly answers 403, not 404, for an app held in an org the token can't see.

  • The setup skill (docs/SKILL.md) asks where AgentRun should run before it installs or deploys anything. The assistant presents four places with one line each (this computer, a machine the person already runs agents on, a hosting provider, AgentRun Cloud) and waits for the answer. "Set it up", "self-host" or "on my machines" no longer counts as a choice, and it never creates a service on Render or another provider the person did not name. Before that question it asks which scheduled, triggered or always-on agents the person already runs and, with permission, reads this machine's cron, systemd timers (system and user), launchd jobs and CI schedules for Claude Code and Codex jobs, so AgentRun goes where those agents live and they are the ones connected. That reading is one script in the skill: it reads the command each job runs, which a list of timers or launchd labels does not show, and returns only where the job is, its schedule and the runtime's name, so a prompt, key or environment value written into a job stays on the machine. A job that starts an agent through a wrapper script is not visible to it, so the assistant asks before concluding there are none.

  • The setup skill (docs/SKILL.md) is the one setup prompt, ordered for a finished first run in about five minutes. The website serves the same text at https://agentrun.ai/SKILL.md.

    • Every choice is a question asked with the host's question tool (Claude Code's AskUserQuestion, Codex's request_user_input, Cursor's AskQuestion, OpenCode's question), with the recommended option first and the reason for it. A host with no such tool gets a numbered question and the assistant stops until the person answers.
    • It reads the session first and says up front when it is a hosted cloud session or sandbox the person's browser can't reach. There the hosted option comes first. The check prints the names of the signals it finds, never their values.
    • Its first call asks two questions before any install or deploy: where AgentRun should run (this computer, the person's own always-on machine over Tailscale, or a hosted service, then Railway, Render or AgentRun Cloud, each with its cost), and whether to look read-only for the Claude Code and Codex jobs the person already schedules. A signed-in provider CLI, a deploy button or render.yaml is still never a choice.
    • A job it finds becomes the first run: connected on its own sign-in, its history imported with no model key, then run once through AgentRun on the person's OK.
    • With no job to bring in, the model step offers Continue with ChatGPT, then a capped OpenRouter key, then a local Ollama or LM Studio model when one with tool calling is already pulled. A key from the Claude Console organization linked to a Claude Max, Ultra or Team plan uses that plan's monthly API credits.
    • The template agent names "place": {"mode": "runner"}, and "thinking": "low" on a local model, so its first run starts at once and its answer carries no reasoning.
    • README.md and docs/getting-started.md tell a coding agent to "set up AgentRun for me" rather than "locally".
  • The Learning tab shows the owner's bill: run after run, what the agent has cost with learning (every run that does a job, its look-back, grade, audit shadow run and its share of its workflow revision's compile and check, booked dollars only), cumulative, against the agent doing all of it (the mean of its own runs before its first run on a served path, times the runs), with a break-even marker where the bill falls to that line and stays, or "not yet" with the gap. Under it, the audit line (agreement over the hold window and all time, each hold at the run the server placed it on) and the serving workflow's nodes with their tiers, code checks and the check it was promoted on.

    • GET /agents/{id}/learning/cost has bill: its points, the baseline, the first served run, break_even or gap_usd (spend booked after the last point included), the runs withheld, each revision's compile and check spend as its next compile_after served runs carry it (a revision is its workflow and its digest: two workflows of the same text each pay their own way), what no run carries (unattributed_usd: the booked total less every run's all-in) and each hold at its run (holds).
    • GET /agents/{id}/learning/promotions has each serving workflow's champion: its nodes with their tiers and code checks and the check it was promoted on, read by the champion's recorded digest and commit.
    • GET /runs/{id} has path, and its cost.usd is the job's own: cost.learning_usd is what learning spent for the run (its look-back, a compile turn left out, its grade, its audit's shadow run, its share of its revision's compile and check) and cost.all_in_usd the two. A compile turn is its revision's; one whose drafts all failed is in the bill's unattributed_usd. Every run's all_in_usd plus unattributed_usd is the bill's total.
    • A shadow run is in no run list, sends no webhook and is no run of GET /stats or the analytics' counts; its cost stays in their dollars, on the day and in the groups of the run it audits.
    • The cost series' run figures, the bill's dollars and a run's cost.usd, cost.learning_usd and cost.all_in_usd are as booked, their float noise rounded off at 1e-12, no longer rounded to 1e-6: a decision's sub-micro-dollar cost is in them, and a run's cost.usd is what its usage row books.
    • The server has deleteLearning, the learning half of an agent's delete: the learning folder (its git history and audits.jsonl) and the agent's promotion, grade and eval records, refused while learning work is in flight, and safe to call again after a crash.
    • Upgrading: cost.usd on GET /runs/{id} is now the job's own spend, so a run's look-back and compile spend move to cost.learning_usd (a compile turn's to the runs its revision serves), as does a served run's audit shadow cost. Read cost.all_in_usd for what learning added to the run.
  • curl -fsSL https://agentrun.ai/install | sh -s -- --tailscale, or agentrun service install --tailscale, also shares AgentRun on your own Tailscale network only (tailscale serve, never Funnel) and prints its https:// address there, where the first visit asks for the setup code; the server itself keeps listening on loopback. Where Funnel is on for that address, or the address already serves something else, nothing changes and the installer says why. When Tailscale is missing, stopped or signed out, or Linux needs operator rights, AgentRun installs and starts anyway, and the installer prints the steps and the command to run again; it never installs Tailscale, signs in or runs sudo. --no-tailscale or agentrun service uninstall removes the serve entry only while it still points at AgentRun (#3122).

  • A Railway template deploys AgentRun Server from the published image (agentrun-server:beta): one service, a volume at /data, the health check on /v2/health, a token and a seal key generated once per deploy, and the server's public address set to the service's Railway domain. deploy/README.md has the Deploy on Railway button, and a section per button with its cost and what happens after the click. On a Railway address the console's setup-code hints name the service's Variables tab and Deploy Logs. The Render docs and render.yaml say that agents there get no shell (#3106).

  • A server whose data directory is a mounted disk starts. Its first-start check for an earlier version's files stopped with EACCES on the disk's lost+found (root's, mode 700); it now skips any path it can't look into (#3106).

  • A Codex run under a small spend cap no longer stops early on a hold that overstated its next request. A request that only adds items to the session's last billed request is held at that bill plus what it adds, and once the run has seen its model reason, a request's least output is 1,024 tokens plus twice the most reasoning one answer reported. The hold is still the request's worst case, so the cap is never passed. A final answer the cap cut ends the run saying so, with the cap that would let it finish (#3127).

Install

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