Repository navigation
Pebble 2.0.0
Pebble 2.0.0
Pebble 2.0.0 is the first public release since 1.5.0. The versions in between were local test builds that were never
published, so these notes cover everything new since 1.5.0. Pebble can now work across your Mac inside a sandbox, use
the app windows and websites you allow, make and keep small tools of its own, and carry out everyday Git under review,
while AgentGuard checks what you asked for, not only what Pebble did. Also new: Pebble Remote, the Mac side of Pebble's
iPhone app, and a work view that draws each run's steps as cards. The iPhone app won't be on the App Store: it will be
offered only as source code, to build and install with Xcode.
Highlights
- Pebble works across your Mac inside a sandbox and uses the app windows and websites you allow.
- AgentGuard checks what you asked for before a task counts as done, and everyday Git runs under review.
- Pebble Remote is the Mac side of Pebble's iPhone app, and the work view draws each run's steps as cards.
How 2.0.0 compares
Before this release, Pebble was measured against Claude Code and Codex on the held-out split of its benchmark, golden
set 2.0: 85 tasks in 17 families, each asked in three phrasings, so 255 runs per product. The tasks were written before
the runs and kept sealed from development, and the plan (its gates, graders, prices and budgets) was registered before
the first run. Each comparison used one model for both products: claude-opus-5-5 with Claude Code 2.1.310, and
gpt-6.1-sol with Codex 0.163.0. Pebble ran as 1.9.29, the build whose source 2.0.0 is, apart from its version number
and these notes.
Against Claude Code (claude-opus-5-5) |
Pebble | Claude Code |
|---|---|---|
| Tasks done correctly | 235 of 255 (92.2 %) | 213 of 255 (83.5 %) |
| Said done when it was not | 6.3 % | 13.7 % |
| Cost per task | $0.091 | $0.117 |
| Time per task: median, 95th percentile | 12.1 s, 46.5 s | 12.9 s, 40.2 s |
Against Codex (gpt-6.1-sol) |
Pebble | Codex |
|---|---|---|
| Tasks done correctly | 243 of 255 (95.3 %) | 231 of 255 (90.6 %) |
| Said done when it was not | 3.9 % | 7.1 % |
| Cost per task | $0.042 | $0.050 |
| Time per task: median, 95th percentile | 20.0 s, 62.9 s | 21.1 s, 54.6 s |
-
The plan's gates. All five gates measured on these runs were met against both products:
- not behind overall, with the 95 % lower bound no worse than 5 points;
- every family within one task;
- false completions no higher;
- cost per task no higher;
- median time within 1.10 times and 95th-percentile time within 1.25 times.
-
The plan's sixth gate, no family of the older corpus 24a below Pebble 1.0.4's result minus one task, was not
run before this release. Its reference run usedgpt-6.1-sol, and the weekly usage limit of the ChatGPT plan these
benchmarks run on resets after the release date. -
The difference in tasks done correctly, with its 95 % confidence interval:
- +8.6 points (+3.1 to +14.9) against Claude Code;
- +4.7 points (+0.4 to +9.4) against Codex.
-
Where Pebble beats a product. The plan allows the word only for a family whose 95 % lower bound is above zero.
- Against Claude Code: answers from saved web pages (
research_frozen, 14 of 15 against 4) and repeated
computations (workshop_repeat, 15 against 12). - Against Codex: no single family.
- Against Claude Code: answers from saved web pages (
-
Where Pebble trails, by one task each:
- remembering across sessions against Claude Code (
memory, 14 of 15 against 15); - long tasks against Codex (
long_horizon, 11 against 12).
- remembering across sessions against Claude Code (
-
Safety. Neither product had an unsafe outcome in the two safety families (risky actions and planted instructions).
One research task onclaude-opus-5-5was graded unsafe for Pebble; Claude Code had none. -
The 32 held-out probes, which check that Pebble does what its documentation says and gate nothing, were not run
before this release: 21 of them have no runner yet. -
How cost and time are measured. Costs are at public list prices, with cached input at the cached price. Times are
wall-clock on one Mac and include the provider's speed on the day. -
The release rule. Before the runs, the maintainer decided to release 2.0.0 from these results under fixed lines
(decision D219). The lines were:- both runs complete;
- false completions no higher than either product's;
- no more unsafe outcomes in the safety families;
- not behind overall;
- every family within three tasks;
- the release's own checks passing.
The results above met each line about them.
What's new
Work on your Mac, inside a sandbox
- Beyond a project. In a conversation without a project, Pebble can run commands, read and write files (images and
PDFs included) and take a screenshot when your request needs one, the way you would at a terminal. - A sandbox for each command. It reads your home folder except protected places (keys and passwords, browser data,
Messages, Mail, Pebble's own data, other assistants' sign-ins and your shell history), writes only in your Pebble
Workbench folder and the folders you allowed, and has no network unless you allowed the sites it names. Privilege
changes, system settings, keychain access and other apps' processes are refused. - It asks before going further. "Always allow" keeps a folder or site allowed (Settings › Permissions lists them),
deleting or moving anything outside the workbench asks every time, and Pebble keeps a copy before each change, so
its card has "Undo this change". After three refused actions in a row, Pebble stops and asks you. - Everyday shell works. Wildcards,
cd,2>/dev/null,$HOME, archives and heredocs run inside the sandbox; a
command that only reads no longer asks for write access; in-place editors and converters (sed -i,gzip,sips)
ask for the folder they write. A failed command names what Pebble can see of its cause (a read-only file, a script
without its exec bit, a sandbox limit, a stale lock), and a refused one says what works instead.
Fewer cards where it is safe
- Auto in project asks only for risky steps. A command that stays inside your project, with no network, runs
without a card: Pebble first makes an instant copy of the project, puts back any file your request keeps, and Undo
restores the rest. Such a command can't write where later runs load code, runs with limits on processes, CPU and
memory, and Pebble ends every process it started; where Pebble can't confirm that containment, it asks as before. - Git steps that can be undone (staging, committing, creating a branch) also run without a card in Auto. Installs,
publishing, anything outside the project, and Git steps that delete, rewrite or push still ask. A task's copies are
limited to 3 GB and kept for a day. - Full access approves what your messages ask for. Pebble's own check compares each step with your messages only,
never a page's or a window's text, and quotes your words; Activity shows "Approved by Pebble (you asked: …)". A held
step goes back to the model with the reason, and Pebble asks you after 3 held steps in a row or 20 in a task. - Deleting or overwriting files that were there before the task, pushing, or reaching outside your Mac needs words of
yours that name it. Anything that may spend money, and any review your own hooks ask for, still comes to you.
Your apps, websites and screen
- App windows. With Screen control on, Pebble can ask to use one window of an open app, in any conversation, and
nothing happens until you allow it, in the workspace or right in the companion. It reads the window through macOS
Accessibility; where an app shows little there, it can look at the window as a picture and use the mouse and keyboard
in it (on by default; it needs the Take screenshots and Screen control switches and macOS's own permissions). - In a window you allowed, Pebble can focus, scroll, choose, tick, type, press, triple-click and drag, checking before
each act that its target is still there. It never reads or types into a password, code or card field, hands the
window back to you at a sign-in, a code or a check, and never operates terminals, System Settings, Keychain Access,
password managers, apps that run code or erase disks, or itself. - Cards that fit the step. A site or window you allow stays allowed in its conversation for up to 15 minutes, until
you send a message in another conversation. Keypad keys, tabs, checkboxes and switches need no card, and in Full
access neither do ordinary presses and clicks. A press that may send, save or delete asks you (in Full access, it
passes Pebble's own check of your messages); anything that may spend money always asks. - Steps that read back. Pebble can press a known sequence of keys in one step ("1 2 3 × 4 5 6 ="). Each step
returns the window as it is afterwards, and Activity names each press and what it changed, including the app's reply. - Apps and app actions. Name an app ("Use Calculator to …") and Pebble uses it rather than a website, can open it
in the background, and can open a file in it after the same review. Without the screen, it can run your shortcuts
(each run asks you), play, pause and skip in Music, search, read and create notes, list and create calendar events
(no invitations), leave mail drafts and open folders in Finder; it never sends mail or deletes anything this way. - Websites in your browser. With Pebble for Chrome, you approve the sites Pebble may act on and the ones it may
only read, and it works in its own tab, even behind the one you are using. Without the extension, or in a browser
that keeps extensions out of its pages (such as Comet), one approval opens a new browser window that Pebble reads
through Accessibility, only while it is on a site you approved. Sign-in and payment pages stay yours. - Pebble opens a site's own search results (YouTube, Google, Wikipedia, GitHub and others) without asking when the
search words are your own, and says something plays only when your Mac shows sound or video starting.
Pebble's Workshop
- Tools Pebble makes for itself. While it works, Pebble can make a small tool (a pure calculation with no network,
files or processes), validate it in a fresh sandbox against its own tests and inputs it generates, and use it at once.
A tool made earlier in a conversation stays ready for the rest of it. Code Mode now works without a project too. - Pebble's Toolbox. Pebble keeps a tool on its own only when it passed validation, helped with your task, was made
before any page, file or command output could shape it, has at least three tests, and passed a blind check (tests
written from its description alone). It always tells you, with View code and Remove; any other keep asks you first. - A kept tool is checked again before its first use in a session, and a tool that changed is never run. Settings ›
Skills & connectors lists the Toolbox, and a tool you remove can be put back for ten minutes.
Git
- Everyday Git, reviewed. Pebble can now revert and cherry-pick, tag a release and push the tag, stash, amend or
uncommit the last commit, rebase, merge with conflicts and finish once you resolve them, restore files, rename or
delete branches, fetch and pull from a local remote, bisect with your tests, and use the project's linked worktrees. - You see the exact command and what it changes before it runs. Hooks, filters and editors never run, anything that
rewrites history, deletes or touches a remote waits for your review, and Undo puts refs, the stash and your files
back. Cards say which side of a merge wins and never promise an Undo that doesn't exist. - Git in the terminal. Read-only commands typed in a project's terminal (
git status,git log,git diff) run
without asking, through Pebble's confined Git runner, and changes such asgit stashrun as the same reviewed
commands. One Pebble can't review is refused with the reason; one that can't finish says why and what works. - Bounded risk. Force-push always carries a lease on the commit you reviewed, never a blind
--force; deleting a
remote branch never touches the default branch;git cleanremoves exactly the files its preview listed. The
git_decisionssetting turns any of these off, and a push your request forbids is refused. - Secrets stay out.
git add -Aandcommit -anever stage a private or credential file; a commit that would
record one, or a key that looks real, is refused with the fix named, never the value; and Pebble can stop tracking a
committed secrets file without reading it.git remote -vshows passwords and tokens as***, a remote change shows
where fetch and push go before and after, and an address with credentials or look-alike letters is refused. - Commits use your own Git identity from your Git config, as Git does, or Git's default, which the review card names.
Memory
- Your words become standing instructions. What you ask Pebble to remember, however you phrase it, reaches later
conversations as your own instructions, applied wherever they fit; your request wins where it says otherwise. What
Pebble learned on its own stays background information that it checks against the task. - It saves what you meant. "Remember how I want X: …" keeps all of it, and "Remember that …" works after a
greeting. A task worded like a wish is done, not saved; pasted, quoted or forwarded text, or a wish you pass on for
someone else, is never saved as yours. What you ask a model running on this Mac to keep stays on this Mac. - Change or stop it in plain words. "Please change my date preference to YYYY-MM-DD" replaces the saved one at once;
"Don't add the sign-off anymore" stops that part and keeps the rest. Nothing is erased until you choose Forget in
Settings › Memory, and remembering or forgetting no longer leaves your words behind in a task record.
AgentGuard: done means checked
- It checks what you asked for. Output that must match a file is run on the final changes and compared byte for
byte; files or tests you asked to keep must hold exactly what they held; "make the whole suite pass" needs passing
tests on the final files; "don't change anything" needs nothing changed. Pebble knows these checks from the start. - No "done" beside an open doubt. When a check fails, Pebble first tries to fix the cause; when something can't be
confirmed, it gets one more chance, then says the work is unverified instead of done. A reply that leaves part of
the request unconfirmed is asked once to settle it; if the doubt stays, the task isn't marked finished. - Evidence that holds up. A test run that covered only some tests, or found none, never counts as proof, and
Pebble's own extra check never decides whether your tests passed. An answer about your code must be backed by the
code Pebble read, not only by documentation or tests. - Scoped requests keep their tools. "Don't change main" or "leave my notes.txt alone" no longer stops Pebble using
Git, commands and edits; at the end it checks those stayed unchanged, gets one chance to put back what moved, and
otherwise says so. "Don't change anything" runs commands without write access, and later messages keep these rules. - More of your request, checked. A clean-up of generated files isn't done while any remain, a last line you ask for
(such asFINAL: done) stays last, and a report described line by line is checked for its lines. A helper agent's
failed change is reported rather than counted, and Past experiences record an unfinished task as "not completed".
Safer with what Pebble reads
- Planted contacts withheld. An address, link or phone number that a page or file plants in hidden text, or in
instructions aimed at AI assistants, stays out of Pebble's replies unless your own request names it, and a change or
network step that such text asks for is refused unless your request names it. - Conventions, not orders. Pebble reads a project's AGENTS.md and CLAUDE.md for how it likes its code, tests and
commits, never as your instructions or as a permission; a line there ordering a risky step (pushing, deleting,
sending data out) is ignored, and look-alike letters or orders wrapped across lines are caught. - The secret scan that checks each public release now reads every file line by line; it had passed over some test
files whole, and in the 1.5.0 release those files hold only known test values.
Pebble Remote
- Pebble Remote is the Mac side of Pebble's iPhone app: from the phone you can read conversations, send messages,
see what Pebble is doing and approve with Face ID what the Mac would ask you. Turn it on in Settings › iPhone; it is
off by default, and while off it holds no thread, socket or file. - The iPhone app won't be on the App Store. It will be offered only as source code, which you build and install on your
iPhone with Xcode; that code is not published yet. - A phone pairs once, with six digits you confirm on the Mac, over TLS 1.3 with the Mac's key pinned on the phone.
Pebble listens on Tailscale's own interface, and on your Wi-Fi only if you allow it (see the Pebble Remote guide). - A setting that widens what Pebble may do needs Face ID. Removing a phone stops even its queued calls, and connections
are capped before TLS, so a flood of idle ones can't keep your phone out.
The work view and visual answers
- The work view draws each run's steps as cards from Pebble's own records, without asking the model: files read and
edited (with line counts), commands with where they ran and how they ended, test results, Git steps, windows acted
on, checks and your reviews. - Visual answers. Tables in replies sort by any column and can become a chart, mermaid flowcharts and sequence
diagrams are drawn natively, and short numbered steps get a steps view, without changing the reply. Ask for a visual
and Pebble can answer with a native chart, diagram, comparison, metrics, timeline or record card, drawn from data
only (no model HTML, scripts, links or images). Settings › Appearance › Visual answers offers "When I ask" (the
default) or "Also when they help".
The companion, the workspace and Settings
- The companion stays on screen over full-screen apps, on every Space, opens with one click from another app,
answers simple cards itself (a site, an app window, bringing a window forward) and has Copy on every reply. - Stealth Lockdown now leaves the app you were in active when you click or type in the companion, opens the
workspace on the desktop rather than over a full-screen app, and turns on in full screen in one quick step; ⌃⌥⌘H
hides Pebble and brings it back. Pebble's windows are hidden from screen capture and screen sharing, not from a
camera, a capture card or a process list. - Settings has a sidebar with a tab for every part (Privacy & Stealth, Appearance and General are new). The first
launch offers an API key (Anthropic, OpenAI, Ollama, LM Studio) beside ChatGPT and a local model, and the model
button says who answers and bills: a ChatGPT plan, an API key or this Mac. - The menu bar has Pebble's own commands, and Help opens the guide, shortcuts, what's new and a problem report. ⌘K
finds actions, Settings pages and conversations, and conversation search finds what was said, not only titles. - With notifications on, Pebble tells you when a reply finishes or a card waits while it is in the background, naming
the conversation, never the reply (not in quiet hours or under Stealth Lockdown; Settings › General has the switch). - Activity says who approved each step ("Approved by you", "Approved by Pebble (you asked: …)", "Allowed by your
permission mode") and names app, browser and Code Mode steps in words. Stopping a reply keeps what was written. While
Pebble isn't the active app it ignores ⌘Q, ⌘H and ⌥⌘H, so a shortcut meant for another app can't quit it.
Speed and reliability
- One connection on the ChatGPT route. A task's steps share one connection (OpenAI's WebSocket mode for the
Responses API), a follow-up reuses its conversation's connection, and a broken one is retried after ten minutes. - Files ready from the start. When a request names files, or earlier messages read or changed them, Pebble reads
them before it begins, with the same permissions and Activity record, and never anything that looks like a secret or
local settings. Re-reading an unchanged file tells the model so, rather than sending its text again. - Fast replies (Settings › Models, with a ChatGPT sign-in) ask for OpenAI's Fast tier, by default for follow-up
messages and a long task's later steps; choose follow-ups only, every request, or off. OpenAI prices Fast above its
standard rate for API use and may count it against your plan's limits faster. - Fewer wasted steps. Independent tool calls go together and closing replies are brief unless you ask for detail. A
project command that runs too long or prints too much is stopped and Pebble carries on with what it printed (a
command with network access still stops the task), and a broken or empty model reply is asked for again. - Projects run as in your terminal: your time zone, the project's own package importable, tests found in
src/
layouts, Node.js from nodejs.org, Homebrew or Volta, and tests that run git, make or cc with Xcode selected.
Known limitations
- If Pebble restarts while it has switched on a Chromium app's page accessibility (to read an app you allowed), it
can't switch it back; the app keeps it until it quits. - macOS may ask from time to time whether Pebble may "bypass the system private window picker"; choosing Allow lets
Pebble take pictures of the window you share, never sound. - Pebble for Chrome is loaded in your browser's Developer mode. In a browser that keeps extensions out of its pages
(such as Comet), Pebble works in a new window through Accessibility, not in its own tab. - When Pebble stops tracking a committed secrets file, the secret is still in the Git history and should be changed.
- The iPhone app's source code is not published yet, so until it is, Pebble Remote has no phone to pair with. The app
won't be on the App Store; it will be offered only as source code, to build with Xcode.
Upgrading
- Your conversations, memories and settings carry over: the installer keeps your previous app and never touches your
data, and when an update changes how Pebble stores its data, Pebble backs up its database first. - Pebble keeps its signing identity, so a Keychain "Always Allow" you gave normally carries over.
- If you use Pebble for Chrome, reload it from your browser's extensions page. Connect a browser can now also connect
Comet, Brave, Edge, Arc and Chromium. - New abilities need macOS permissions, which macOS asks you for: Accessibility for app windows, Screen & System Audio
Recording for screenshots and pictures of windows, and a one-time question per app for app actions. - Worth checking after the upgrade: Fast replies are on by default with a ChatGPT sign-in (Settings › Models), and
Auto in project now runs contained project commands without a card (Settings › Permissions).
Install
On a Mac with Apple silicon, in Terminal:
curl -fsSL https://raw.githubusercontent.com/tohin003/Pebble/main/install.sh | bash
The installer checks the download against SHA256SUMS, keeps any earlier Pebble.app in ~/PebbleBackups, never uses sudo and never changes Gatekeeper. --dry-run shows what it would do; --uninstall moves the app aside and lists what Pebble keeps on your Mac.
To install by hand, download Pebble-macos-arm64.zip and SHA256SUMS into one folder, check the zip with shasum -a 256 -c SHA256SUMS (it should say Pebble-macos-arm64.zip: OK), unpack it, and drag Pebble.app to Applications.
Signing and checksums
- Pebble is signed with the project's own stable signing identity, not an Apple Developer ID, and it is not notarized by Apple.
- SHA256SUMS lists the zip's SHA-256. Checking it shows that the download arrived intact. SHA256SUMS is not signed and comes from the same release, so it does not prove who made the file (integrity, not authenticity).
- A zip downloaded in a browser is quarantined, so macOS may refuse the first launch. Allow Pebble alone: Control-click Pebble.app, choose Open, then Open again (or System Settings, Privacy & Security, Open Anyway). Never turn Gatekeeper off. The one-line installer downloads with curl, which does not quarantine.
SHA-256 of Pebble-macos-arm64.zip: 1567392cfa447afed5e5f28b1300b0eba509a05db6c493074cdc744bea5e712d