What we shipped.

Talking to Leroy is now noticeably snappier. We moved the chat orchestrator onto a faster engine with streaming tool-use, so Leroy thinks, calls tools, and answers in real time instead of making you wait for the whole turn to finish.

Two new things it can do mid-conversation:

It can see images.Paste a screenshot of a broken UI or a design, and Leroy actually looks at it — describing, debugging, and acting on what's in the picture instead of asking you to type it all out.

It can draft your emails. Ask Leroy to write an email and you get a clean, formatted draft with a single confirm-and-send button — you stay in control of what actually goes out.

• "Send that last result" now correctly skips over email-draft turns instead of resending them.
• Utility classifiers (routing, environment detection) moved to a faster path for quicker first responses.

Statuses and reports are now the same thing: a saved rule— a query over your work that you can name, re-run on demand, or run on a schedule. Ask once ("what's waiting on me to review?"), save it, and check back any time.

Get the answer in your inbox.Saved rules can deliver as clean, readable emails on a schedule — so the weekly "where are things" summary just shows up instead of you going to ask for it.

• Set priority and due dates on any request.
• Report emails use a proper template — they read like a digest, not a data dump.

When a piece of work ships, Leroy now distills what it learned from the entire ticket — the discussion, the code, the review — into its knowledge base, not just from the final commit. The next time you ask for something related, it already knows how your codebase and your preferences work. It gets sharper the more it does.

• Skills are now created automatically on ship and refined through a learning loop.
• Hardened tenant isolation with row-level security so one account's knowledge can never reach another.
• Removed fail-open token routes and added verification on incoming Sentry webhooks.

This is the big one — and it's what the shipping bottleneck post is about. Writing code got cheap; trusting it never did. Two features attack that directly:

Change verification. A review agent reads the diff, builds ared→greentest plan — the things that should pass, the things that should fail — and then runs it. You get checks, not "trust me."

One-click live preview.One click drops you into a real environment with the change live: it provisions the frontend and backend together, seeds the data you need to exercise it, and logs you in. The exact setup that used to eat an afternoon — gone. You click, and you're standing in front of the running change.

• Previews rebuild automatically on each new commit and tear down on merge or close.
• Verification failures never block a PR from being created — they're surfaced, not fatal.

• Merge a PR → the request ships itself — attention cleared, marked done, no extra bookkeeping.
• Leroy commits as its own GitHub App bot, so CI and Vercel previews accept its changes.
• Per-account GitHub auth across the coder and reviewer, and multi-repo support for work that spans services.
• Your source code only ever runs in an ephemeral, isolated sandbox — it's never persisted on our infrastructure.