Personal Agent Bench

Also in日本語简体中文한국어

Meta Muse vs Pine AI, and what a machine of your own is actually for

Muse logoMuse

A VM of
your own.

Muse gives each user a Linux VM, and browser work spawns a second, separate machine.

246 methods on a permission sheet, carrying no parameters

Pine logoPine

Borrowed
ones.

Pine runs server-side. Browser work is handed to a separate agent on your own computer, while the cloud route leases a remote desktop you watch over VNC.

26 tool names reach the client

Both retain state: Muse uses files on its VM, while Pine has a persistent server-side fact service. What persistence buys.

Last verified 2026-10-26

Three differences

What it is

Muse Meta's personal agent, with a Linux machine of your own behind it.

Pine Phones companies on your behalf about bills, refunds and cancellations.

Phone calls

Muse is only starting to: Meta's guidance says business calling is in early access, and the account we examined didn't have it.

Pine phones companies on your behalf about bills, refunds and cancellations, and it is built around doing so.

When you approve

Muse attaches the confirmation to a gatekeeper every outside action has to pass, with an approvals tab beside the activity feed.

Pine attaches it to the task: a start confirmation, and an identity confirmation when the company on the phone wants to hear from the account holder.

What it remembers

Muse keeps plain markdown in a home directory, embedded straight into the request.

Pine keeps a persistent server-side fact service: a fact layer you cannot open.

What the same tasks showed

Two kinds of evidence follow: what we observed in the products, and what happened on shared tasks using adapted runtimes. The task results do not tell us which product decision caused an outcome.

Separate batches of adapted runtimes using a substituted model, not end-to-end results for the consumer apps. No combined score or ranking.

October

20 shared tasks, one attempt each

  1. Muse58% (36–77) · 19 tasks
  2. PineNo data, exam fault

September, same tasks

114 shared tasks, older rules and builds

  1. Muse40% (33–46) · 114 tasks
  2. Pine30% (23–36) · 114 tasks

September, own draw

Each product answered its own draw, so rates are not directly comparable.

  1. Muse19% (13–25) · 90 tasks
  2. Pine20% (14–25) · 167 tasks

95% interval measured rateProduct runtimes rebuilt for the exam with one substituted model, not the consumer apps measured end to end. Results and caveats

Meta Muse vs Pine AI is the cleanest test of a question the whole category keeps dodging: does a personal agent need a computer of its own. Muse answers yes twice over, giving every user a Linux virtual machine and spawning a second one when browser work is needed. Pine answers mostly no: the model runs on its servers, and when it needs a browser it either hands the work to a separate agent on your own computer or leases a remote desktop. Both products then go and do errands for you, so the arrangement is not decorative. It changes where each one keeps state and where its browser work happens.

  • Both retain state: Muse uses files on its VM, while Pine has a persistent server-side fact service.
  • That shows up most clearly in memory: plain files in a home directory against a fact layer you cannot open.
  • Pine makes phone calls, which is the one capability here that leaves software entirely. Meta's own guidance inside Muse says business calling is arriving there too, in early access, and the account we examined didn't have it.
  • Neither will show us the instruction text, and in both cases that is the part that decides behaviour.
  • Pine has no October completion figure, because its submissions never reached the exam in that batch. Muse's October figure sits beside its September ones, never merged with them.

The basics first. Muse is Meta's. Meta's launch post of 8 September says it is rolling out in the US on iOS, Android and the web (Meta's Japanese newsroom adds Japan from 23 October, and its Singapore announcement adds Singapore from 27 October), and is free for most of what people need, with subscription plans for people who want to do more; it names no prices. Pine is sold at 19pine.ai, and its App Store listing names the developer as 19Pine Corp. It publishes its prices: personal and household prices are displayed per week, and work prices per month; these units do not establish renewal cadence. Confirm billing cadence and fees at checkout. Both pricing pictures are on our teardown pages, Muse and Pine, so they stay in one place when they change.

Meta’s security account describes a dedicated Muse Secure VM and a separate Sentinel agent that controls connector actions and network egress. These are Meta’s claims; our teardown did not test those controls.

The Muse and Pine runtimes, side by side

Show the scorecard rows
AxisMusePine
Where it runsOne Linux VM per user. The request is assembled on that machine rather than fetched as a finished blob. Browser work spawns a second, separate machine.Server-side. Neither the web app nor the Mac app runs the model. Browser work is handed to a separate agent on your own machine; the cloud route leases you a remote desktop you watch over VNC.
How tools are exposedTwo layers kept deliberately apart: a permission sheet of 246 methods carrying no parameters at all, and the real definitions loaded a namespace at a time when needed.26 tool names reach the client, grouped by job. The schemas never do. Computer use bypasses that list entirely.
Where memory livesPlain markdown in a home directory, embedded straight into the request. Changing one of those files inserts a short note rather than rebuilding the whole package.No file you can edit. A server-side persona plus a structured fact layer queried on demand.
What you get to approvePermissions and approvals are not scattered through the runtime. A single gatekeeper is the only path to them, along with anything leaving the machine, and the interface carries an approvals tab beside the activity feed. Credentials are held outside the agent's reach by the same arrangement. The examined runtime includes file removal and a forget capability. Whether users can directly open or remove their memory files was not verified.Confirmation is required before a billing action, and there are two separate kinds of it. A start confirmation gates the task and carries its own expiry. A different identity confirmation appears when the company on the phone wants to hear from the account holder: a card naming what to say, which number will be calling, and when the offer lapses. Both the request and the receipt land in the task history. We found no editable local memory file; deletion of server-side facts was not established.
How you reach itLaunched on iOS, Android and the web, and reachable in WhatsApp. A Mac app since 17 September can act in apps on your computer. We tested the web surface only.Web and Mac, outbound phone calls, a voice copilot, and a REST endpoint other people's agents can call. Four request shapes under one brand.
What we could not establishThe raw traffic between the runtime and the model: structure known, contents never seen. Also credentials, live third-party sign-in, and an interactive terminal the owners chose not to open.Production instruction text (roughly 126 probes, all empty), the calling tool's schema, which carrier places the calls, and whether work is split across a fast and a slow model.
Completed, scored subset19%13 to 25 · 90 tasks20%14 to 25 · 167 tasks
Where it runs
MuseOne Linux VM per user. The request is assembled on that machine rather than fetched as a finished blob. Browser work spawns a second, separate machine.
PineServer-side. Neither the web app nor the Mac app runs the model. Browser work is handed to a separate agent on your own machine; the cloud route leases you a remote desktop you watch over VNC.
How tools are exposed
MuseTwo layers kept deliberately apart: a permission sheet of 246 methods carrying no parameters at all, and the real definitions loaded a namespace at a time when needed.
Pine26 tool names reach the client, grouped by job. The schemas never do. Computer use bypasses that list entirely.
Where memory lives
MusePlain markdown in a home directory, embedded straight into the request. Changing one of those files inserts a short note rather than rebuilding the whole package.
PineNo file you can edit. A server-side persona plus a structured fact layer queried on demand.
What you get to approve
MusePermissions and approvals are not scattered through the runtime. A single gatekeeper is the only path to them, along with anything leaving the machine, and the interface carries an approvals tab beside the activity feed. Credentials are held outside the agent's reach by the same arrangement. The examined runtime includes file removal and a forget capability. Whether users can directly open or remove their memory files was not verified.
PineConfirmation is required before a billing action, and there are two separate kinds of it. A start confirmation gates the task and carries its own expiry. A different identity confirmation appears when the company on the phone wants to hear from the account holder: a card naming what to say, which number will be calling, and when the offer lapses. Both the request and the receipt land in the task history. We found no editable local memory file; deletion of server-side facts was not established.
How you reach it
MuseLaunched on iOS, Android and the web, and reachable in WhatsApp. A Mac app since 17 September can act in apps on your computer. We tested the web surface only.
PineWeb and Mac, outbound phone calls, a voice copilot, and a REST endpoint other people's agents can call. Four request shapes under one brand.
What we could not establish
MuseThe raw traffic between the runtime and the model: structure known, contents never seen. Also credentials, live third-party sign-in, and an interactive terminal the owners chose not to open.
PineProduction instruction text (roughly 126 probes, all empty), the calling tool's schema, which carrier places the calls, and whether work is split across a fast and a slow model.
Completed, scored subset
Muse19% · 95% interval 13–25% · 90 scored tasks
Pine20% · 95% interval 14–25% · 167 scored tasks
The completion row covers differing September scored subsets of adapted product runtimes using the substituted exam model, not shipping consumer products. Underlying first-batch records are unpublished; Muse's rate follows an adapter repair. Result provenance and limitations. Neither figure is a ranking and we never combine them. As of 2026-09-22.

Muse and Pine: two machines of Meta's, or borrowed ones

Muse gives each user a Linux VM. The request is assembled on that machine rather than arriving as a finished blob, and browser work spawns a second, separate machine. One user, two computers, both of them Meta's.

Pine runs server-side and neither its web app nor its Mac app runs the model. Browser work is handed to a separate agent on your own computer, while the cloud route leases a remote desktop you watch over VNC.

The phrase to notice in the Muse description is "assembled on that machine". It means the prompt is built where the files are, rather than composed elsewhere and shipped in. Muse's files provide that persistent context. Pine's server-side fact service is another form of persistent storage; it need not carry all retained facts in each request.

What persistence buys, and what it costs

Having somewhere to put things changes what memory can be.

Muse keeps plain markdown in a home directory, embedded straight into the request, and changing one of those files inserts a short note rather than rebuilding the whole package. That last detail is the one that gives the design away: the runtime uses files and change notices. We did not measure the relative cost of editing files and regenerating context.

Pine has no editable local file that we established. It keeps a server-side persona and structured fact layer queried on demand. Both Pine and Muse therefore retain state, but expose different storage arrangements. We did not measure their relative operating costs, establish direct editing of Pine's facts, or verify personal access to Muse's memory files.

Ask what happens when each one is wrong about you. Muse stores context in files and Pine in a fact service, but storage format alone does not establish the correction controls available to you. We did not verify personal access to Muse's files.

Both storage arrangements carry retention, backup and deletion questions. A per-user VM and a server-side fact service may answer them differently, but the storage format alone does not show which is cheaper or better protected. Pine's fact layer is stateful, and its deletion boundary remains unverified.

Permission and definition, kept apart

Muse separates two things most products ship together. There is a permission sheet of 246 methods carrying no parameters at all, and then the real definitions, loaded a namespace at a time when they are needed.

Pine lets 26 tool names reach the client, grouped by job. The schemas never do. Computer use bypasses that list entirely.

Both are withholding, and it is worth being precise about what each one withholds and from whom. Muse withholds definitions from the context until the moment of use, and the permission sheet still says what exists. Pine withholds schemas from the client, which limits what an outside observer can learn; we do not know its reason. The published names do not describe what the product can actually do because computer use goes around them.

Muse vs Pine on phone calls: observed and reported access

Pine phones companies on your behalf about bills, refunds and cancellations, and it is built around doing so. Muse is only starting to. The guidance Meta ships inside the product says Muse can call US businesses for your own tasks, now or on a schedule, once you confirm, with a person or an AI voice making the call. It also says the feature is in early access and reaching accounts gradually, and the account we examined never received the calling tools, so we have not seen a Muse call happen. The same guidance rules out receiving calls, sending texts, cold calls and bulk calls.

For now this is the widest functional gap between the two, and it is wider than it appears, because a call is not another tool call. It puts an agent into a conversation with a person who did not agree to speak to a machine, about an account that belongs to you. When it goes wrong, a call made from Pine's app leaves a summary rather than a transcript: the merchant, the number, the duration, the credit cost and a summary written by the system that made the call. Calls placed through Pine's developer API do return a turn-by-turn transcript. Either way, the human on the other end keeps their own impression of what you authorised.

Pine's other surfaces sit around that. Four request shapes share the one brand: the web and Mac apps, outbound calls, a voice copilot, and a REST endpoint other software can call. The endpoint means a Pine task can be started by software rather than a person typing; we did not establish whether Pine starts work on its own.

Muse vs Pine: which one asks before it acts

Both put a confirmation between the agent and the consequential step. Pine attaches it to the task; Muse attaches it to a gatekeeper every outside action has to pass.

Pine has two separate confirmations. A start confirmation gates the task and carries its own expiry. An identity confirmation appears when the company on the phone wants to hear from the account holder: a card naming what to say, which number will be calling, and when the offer lapses. Both the request and the receipt land in the task history.

In the Muse runtime we examined, permissions, approvals and anything leaving the machine all pass through a single gatekeeper, and the interface keeps an approvals tab beside the activity feed. Credentials sit outside the agent's reach by the same arrangement. Meta says a grant can be one-time, per session, per task, time-limited or perpetual, and that approval prompts go to the app rather than through the conversation. We did not test those options, and Muse's calling flow, which Meta's guidance says needs your confirmation, never reached our account.

The practical check differs. With Pine, read the identity card closely, because it tells you what will be said in your name and from which number. With Muse, review the grants you have left standing beyond one-time use. The control rows for Muse and Pine have the detail.

Where you find Muse and Pine

Muse launched on iOS, Android and the web, is reachable in WhatsApp, and since 17 September has had a Mac app that can act in applications on your computer. We tested the web surface only, which is stated here because it bounds everything else we say about it.

Pine answers on web and Mac, by outbound phone call, through a voice copilot, and over that REST endpoint.

Muse's Mac app matters for this comparison and we have not examined it. The product we took apart was the web one, with its Linux machine behind it. If the Mac app reaches into applications the way the description says, then Muse now spans both ends of the axis this page is built on, and that is a reason to re-examine it rather than a finding.

What neither will show us

For Muse the gap is the raw traffic between the runtime and the model: we know the structure and have never seen the contents. Also credentials, live third-party sign-in, and an interactive terminal the owners chose not to open.

For Pine the gap is the production instruction text, after roughly 126 probes that all came back empty, plus the calling tool's schema, which carrier places the calls, and whether work is split between a fast and a slow model.

Two of those are worth flagging for anyone comparing these products seriously. We have not seen what Muse actually sends the model. And we do not know which carrier places Pine's phone calls, which for a product whose signature feature is a phone call is a larger blank than it sounds.

The interactive terminal in the Muse list is its own small story. The owners chose not to open an interactive terminal to us. We could not verify personal access to the memory files, so their format alone does not establish that you can edit them.

Muse vs Pine: which one the choice comes down to

The two questions that decide it are not the ones a feature list asks.

The first is whether your errands end in a conversation with a company. Cancellations, refunds and billing disputes usually do, and Pine is built around exactly that, down to the shape of its four front doors. Muse is only starting to: business calling is in early access, and we have not seen it work.

The second question is how you want retained context to be exposed and corrected. File storage and a fact service can both accumulate information over time. We have not compared longitudinal learning, so neither format establishes that an agent will know you better after six months. Ask what can be inspected, changed and deleted, then verify those controls in your account.

Put as fit rather than as a ranking:

  • Pine logoPick Pine if the errand ends in a conversation with a company, a cancellation, a refund or a billing dispute, and you want it phoned today rather than in an early-access rollout.
  • Muse logoPick Muse if the errand is work an agent can do on a machine of its own, through connected accounts and a browser, with approvals collected in one tab.

What the Muse and Pine figures say

Both products have a published completion rate on our scorecard, each with an interval and the number of tasks behind it, and the main-table intervals overlap almost entirely. Those products answered different task sets, so similar point estimates do not establish equal performance. The separate common-task measurement below gives a different picture. Pine's figure rests on more scored tasks than Muse's, and Muse's moved after we fixed defects in our own adapter, which the scorecard explains.

Close rates still do not make the products equivalent. The rate does not say which of these two arrangements is better, because the set was not designed to reward having a machine of your own, and a rate cannot see the difference between an errand completed inside a leased desktop and the same errand completed on a persistent VM. Read the rate for what it measures, how scoring works for why we never blend it into a single score, and where it runs for the part it cannot see. If the persistence question is what interests you, Muse vs Instinct puts the same VM against a sandbox.

On the separate 114-task batch, measured on 22 September 2026, Muse completed 40% (95% interval 33 to 46%; 637 attempts) and Pine completed 30% (95% interval 23 to 36%; 546 attempts). Both answered the same 114 tasks. These are replicas of older runtimes with the same GLM 5.3 flash model substituted, under older rules, filtered from roughly 5,600 attempts using eight rules, not fresh product results. Excluding attempts that never reached the exam removes over 400 each for Pine and Muse; if those were refusals rather than broken entry, the supplied alternative estimates are about 22% for Pine and 24% for Muse. Transcripts were supplied but have not been republished here; some files were overwritten or shared between attempts, so the underlying record is incomplete. Keep this measurement separate from the main table and do not treat interval overlap or a point estimate as a significance test.

The October batch, run on 11 October 2026, gave every product the same 20 tasks once each, under the exam rules that took effect at the end of September. Muse completed 11 of 19 scored attempts, 58% (95% interval 36 to 77%). Pine has no October figure: almost none of its submissions reached the exam, so its column was set aside rather than scored as zero, and the cause is not yet known and may be on the exam side. The tasks, the rules and our replicas all changed since September, so Muse's October figure is a new measurement, not Muse getting better, and the batches are never added together. The other October batches, each with its own tasks and builds, are listed separately on the results page, and individual recorded attempts are on the run pages, as counts rather than rates.

The VM description is not the whole shipping product: Muse also has a Mac app, available since 17 September, that can act in apps including Messages and Notes. We examined the web runtime, not that Mac route, so this comparison does not establish how its local app access performs.

The Pine pricing snapshot starts personal use at $9.00/week, dated 2026-09-23. Weekly personal pricing is not directly comparable to a monthly work plan; the page separates billing periods and additional fees.

FAQ

What is the main difference between Muse and Pine? Muse gives every user a Linux virtual machine in Meta's cloud, and a second one for browser work. Pine runs its model on its own servers, and when it needs a browser it hands the work to a separate agent on your computer or leases a remote desktop.

Which one can I correct when it gets something wrong about me? Muse keeps plain markdown files in a home directory, and changing one inserts a short note rather than rebuilding everything; whether you can open those files yourself was not verified, because no terminal was available to us. Pine has no file to edit: a server-side persona and a fact layer queried on demand.

Can either one make phone calls? Pine does, about bills, refunds and cancellations. Calls from its app keep a summary, and calls through its developer API return a transcript. Muse is getting business calling in early access, according to Meta's guidance inside the product, but the account we examined didn't have it and we haven't seen it work. We could not establish which carrier places Pine's calls.

Does Muse run on my computer? The product we examined does not: it runs on a Linux machine Meta provides. A Mac app released on 17 September is described as acting in applications on your computer, and we have not examined it.

How many tools does each have? Muse exposes a permission sheet of 246 methods with no parameters, loading real definitions only when needed. Pine sends 26 tool names and no schemas, and its computer use bypasses that list.

Is this from testing or from their documentation? From our own teardowns of Muse and Pine, including what we could not establish for each. For Muse we examined the web surface only.

Who makes Muse and Pine, and what do they cost? Muse is Meta's, free for most use with subscription plans, and rolling out in the US, in Japan since 23 October and in Singapore since 27 October. Pine's terms name 19Pine Pte. Ltd.; the App Store seller is 19Pine Corp. It publishes weekly personal plans and monthly work plans; the current figures are on our Pine page.

Why do the two completion rates not settle it? The main-table point estimates are close, but they come from different task sets. On the older shared 114 tasks, Muse is at 40% (95% interval 33 to 46%) and Pine at 30% (23 to 36%). In the October batch Muse is at 58% (36 to 77%) and Pine has no figure, because its submissions did not reach the exam. None of these measurements tells you whether an errand finished on a persistent VM or in a leased desktop. The rates are real and they are narrow in what they measure.

Other comparisons

All six pairs, and why there are only six, are on the comparisons page.

More on Muse