What's new
What's new
What's new
Product updates in reverse chronological order. Scoped to changes in the MCP extension and the free web apps: each release has its own permalink for sharing.
Prefer a feed reader? Subscribe via Atom.
22 September 2026
Monthly, annual and lifetime plans are bought at yourorbit.team/pricing through Stripe. For an existing install the whole change is one paste: the extension now needs an activation key, which appears once on your account page at yourorbit.team/account/downloads and goes into Settings → Extensions → Orbit → Activation Key. Without a valid key every tool, every skill resource and every prompt returns a message pointing at the pricing page. Three stay open (orbit_check_setup, orbit_check_version and orbit_list_skills) so a stranger can still see what they would be buying rather than a wall. Versions up to and including 0.43.2 were released under MIT, that grant is irrevocable and is not being clawed back, and an already-installed 0.43.2 keeps working exactly as it is; 0.44.0 and later are proprietary, with the LICENSE inside the bundle. The courses and the 99 practitioner guides on yourorbit.team stay free and always will: that is the site, not the extension. Two independent adversarial reviews, one of them cross-model, went over the money layer before it shipped, and two of their findings were real: an outage that would have read as a cancellation and locked out every subscriber at once, and an environment override that let a non-payer license themselves. Both are closed. 1,562 tests pass on the extension, 144 on the website.
16 September 2026
On 8 September a raw POST /canvas/duplicate returned 202 while Orbit's own orbit_create_braze_canvas returned 403 on the same endpoint. That went into the braze-claude-in-chrome-build skill as a workaround, try the raw endpoint before concluding the key lacks the scope, which is the documentation telling you Orbit's request is malformed. A bug was filed on exactly that premise. The premise was wrong, and wrong in the most inconvenient direction: those were two different API keys. Probed on 16 September with a deliberately invalid canvas_id, which creates nothing and separates the permission layer from the validation layer cleanly, the key holding canvas.duplicate came back 400 ('canvas_id' must be a string of the object api identifier), and the key without it came back 403 Access Denied. Braze refuses on permission before it validates the body. So the 403 was never the payload and never the source canvas id; the same 403 comes back for any id, valid or not. Orbit's request shape was correct the whole time, and the skill spent eight days sending people around a bug that did not exist. The defect was the error, not the request, and that is what this release fixes.
16 September 2026
A round number is a tell. orbit_check_deliverability reported exactly 100 unsubscribes over 30 days on a real account and 42 over 7, and seven days cannot hold 42 while thirty hold 100. Forty-two a week extrapolates to roughly 180, and Braze's own canvas step statistics showed 84 in 14 days. The 100 was the page size. Braze's /email/hard_bounces and /email/unsubscribes default to limit=100, cap at 500 per request, and return no total and no cursor; Orbit passed neither limit nor offset, then reported emails.length as the count. Nothing errored. Any account with more than 100 unsubscribes in the window just got a confident, plausible, permanently-too-low number. Both endpoints are paged now, and three other things in the same tool were wrong in the same direction: thresholds that made the verdict track how long you looked rather than how healthy you were, a recommendation that was busywork, and a health rating that has never been able to see a send total and never said so.
14 September 2026
The update check read a single endpoint on this website. That endpoint stopped being rebuilt on 8 September while four releases shipped, so the check never failed: it kept answering, confidently, and it was wrong in both directions at the same time. Anyone three releases behind was told they were current. Anyone who updated correctly was told they were running a dev build. It now asks three independent sources and takes the newest, and when they disagree it says so out loud instead of picking the quiet one.
10 September 2026
0.42.0 deleted the viewport pins that had every Orbit widget reporting the pane's height back to Claude instead of its own, and shipped a check to stop them coming back. The check was weaker than it looked. Asked to break it, the reviewer did so three times in a row: a calc() wrapper, the newer dvh unit, and worst, the inline style written from JavaScript, which was the single site that had made the whole class of bug survivable in the first place. A stylesheet-only fix would have been cosmetic and the gate would have stayed green through it. All three now fail. A second correction in the same release is smaller and worse: a comment in the shipped code cited a test that was never written.
9 September 2026
Orbit's widgets render in a pane the host resizes by measuring the document inside it. Every one of the 23 pinned its own document to the viewport, body and .wrap both at 100vh, so the measurement handed the pane its own height straight back, forever, and a widget could never ask for more room than it had already been given. On the populated ESP capability matrix at a 520px pane the grid was 45px against 592px of content: the six column headers and none of its eight rows, in the widget whose entire purpose is the grid. It is 592 of 592 now, and the document reports its true 1170px at both a 520 and a 760 pane. This reverses a call published on this page in 0.32.0, which said three widgets were flagged and deliberately not fixed after two attempts made things worse. That note has stood for eleven releases and it is retired here: the item below says what changed the answer, and it was not persistence.
8 September 2026
0.41.0 added braze-operator without going back through the skills that already had an opinion about what the Braze MCP can reach. Every Canvas skill in Orbit said, correctly, that no Braze API writes a Canvas, and then drew the wrong conclusion from it, that the MCP is therefore not a path to one. send_operator_prompt is an MCP tool that drives the dashboard in a live browser session, so the server can build a Canvas even though none of its structured tools can. Three skills now carry that carve-out. One of them was also citing a function count from the wrong server entirely.
8 September 2026
Orbit's three Braze MCP skills shipped on 7 September written from Braze's documentation alone. Connected to the live server for the first time, the documentation was right about four things and silent about the one that stops most builds. get_segment_filters returns a fixed vocabulary of 32 filters and not one of them filters on a custom attribute. Custom events are filterable three ways; custom attributes are not filterable at all, while the same server reads every one of them back through get_custom_attributes. Readable is not filterable, and most real B2B and product-led audiences are defined by exactly the attributes you cannot segment on: plan tier, lifecycle state, feature flags, billing status. Orbit would have started building one and discovered it at step five. The catalog also came back byte-identical across two different workspaces, so it is platform-fixed rather than a reflection of what your data holds, which the skill had described the other way round. A new skill covers BrazeAI Operator, the one surface that reaches what no Braze API exposes, and campaign writes gained the concurrency protocol they need to work at all.
7 September 2026
Orbit's install screen opened on "Free lifecycle marketing in Claude: no licence key, no payment, every tool unlocked", and the router's own first sentence, the one Claude reads before anything else in a session, was "a unified lifecycle marketing operating system for advanced CRM, growth, and martech work", which no product could fail to be. Neither said the one thing a stranger can watch Orbit do in a minute: check an email in a real browser before it is sent. Every door now opens on that. The manifest description, the README, the router's opener and the homepage all lead with the deed and close on the price. Saying the sentence turned out to be the easy half. Typed into orbit_route_task on 0.39.1, "check this email before I send it" ranked pre-launch-review at 14 over email-render-qa at 9, and "build me a lifecycle brain" resolved to copy-framework at 6 with template-brain nowhere in the top three: the front door was promising work the router could not hear a request for. Both route first now. The router's Skill Index, which listed 53 of the 86 skills it ships, lists all of them, and its own description stops claiming 62 protocols and 84 tools. Underneath: orbit_lifecycle_diagram crashed on any spec that had lost its mermaid blob, and had since the first commit.
7 September 2026
"Build me a Braze canvas with three branches" routed to the Braze documentation expert, a skill that explains Braze rather than builds in it. The router was not miscalculating. The documentation skill's own description listed "build this Canvas" among its trigger phrases and opened by claiming everything that involves Braze, including building Canvases, so the router matched a claim the skill should never have made. The Canvas builder, meanwhile, only advertised "design a Canvas" and "build a Canvas layout from this message plan", so a plain "build a canvas" matched nothing at all. The documentation skill now describes what it actually does: answer Braze questions, and says outright that builds belong to the builders. The Canvas builder claims the build phrasings. Braze questions still route to the documentation skill; nothing about how it answers has changed.
7 September 2026
Braze now hosts an MCP server at mcp.braze.com/mcp, and it moves two jobs out of the dashboard that were only ever hand-clicked. Segment writes are the headline: create_segment and edit_segment have never existed in Braze's public REST API, which is why every segment you own was clicked into being rather than authored, versioned, or replicated into a second workspace. Campaign lifecycle is the other: create, edit, duplicate, launch, stop, archive, down to message variations and the traffic split. Three skills ship for it. The one doing the most work is the router, because a connected Braze MCP means three surfaces can now do Braze work (Braze's server, Orbit's own tools, the browser) and choosing wrong costs you an hour before the error tells you. Then the gap everyone is about to walk into. Braze's MCP exposes four Canvas tools and all four are reads. No create, no edit, no step or branch mutation. Every Canvas build is still browser-driven, exactly as it was last week, and that correction is written into braze-canvas-creator and braze-canvas-qa as well as the new skills: because "but Braze has an MCP now" is a reasonable thing to assume and it will arrive there first.
1 September 2026
The empty-promise gate charged a line for its opening phrase and never read what followed. "Best practices we learned fitting 400 boilers" scored 74, "Learn more about the KX-9 recall" scored 74, and "Everything you need to know about the 14 Oct cutover" scored 70: each names something a reader could not have guessed, and each was docked for the three words in front of it. They score 100, 100 and 96 now. The distinction the list was missing is worth having if you write subject lines for a living: a container phrase (best practices, the ultimate guide, tips and tricks, learn more, everything you need to know) names a genre whose contents can be entirely specific, so evidence inside it genuinely rescues it. A hype phrase (supercharge, to the next level, unlock your potential) claims value rather than promising content, and nothing can sit inside a claim, however many digits surround it. The five genuine empty promises are unmoved at 74, including "Best practices for handling callbacks", which opens on the same two words as the first line released. And the free subject-line app on yourorbit.team, which had been quietly scoring differently from the extension since April, now agrees with it.
1 September 2026
A markdown header renders on a background nobody at Orbit controls: a README in either GitHub theme, a Notion page, an editor preview. The one Orbit writes above a report linked the website's dark-INK mark, which measures 21:1 against white and 1.19:1 against the dark theme ground. On a light page it was the sharp Orbit logo. On a dark page it was blank space, and had been for every reader in dark mode. The cause is the part worth passing on: the extension and the website use the word "dark" in opposite senses. In the extension, icon-dark.png is the variant FOR dark mode, so light ink. On the site, orbit-icon-dark.png is dark ink, for light grounds. Same word, inverted meaning, one URL crossing between the two conventions, and nothing in either repo positioned to notice. The header now uses the full tile, which is fully opaque and carries its own background: 19.79:1 on dark against 20.87:1 on light. It is the only one of the three marks legible either way, which is the only property a call site with no control over the page can rely on.
1 September 2026
The subject-line scorer got a jargon detector in 0.34.0, and a line can be empty without containing a single word of jargon. "An update about your account" is grammatical, the right length, punctuated correctly and carries no buzzword to catch, so it sailed through at 100/sharp. It scores 66/risky now, on a rule that looks for evidence rather than banning words: a line is empty when every token either is a grammatical stopword or names only the existence of a message (update, notice, details, account; important, quick, latest), and there is no number, date, currency or personalisation token anywhere in it. Direction matters more than the list. A word the vocabulary has never seen counts as evidence and clears the line, which is why "Update: your refund cleared" still scores 100: same word, different line. The fix is deliberately partial, and the honest version is below: one ordinary noun clears the check, so "Your weekly report is ready" is empty by the same definition and still scores 100.
1 September 2026
orbit_route_task is the front door: you describe a job, it picks the skill. It could not say "I don't know" to anyone who had finished setup. A platform read out of your config was worth +8 against a match floor of 6, so the floor was already cleared before your request was scored at all, and a woodworking question came back as braze-build-packager with a self-graded 100/sharp. Remove the config and the same question abstained correctly, which is the tell: the router's honesty was a function of your settings rather than your words. Three more leaks sat underneath it, all of them ways for noise to pay out. Scoring is now split into what the request earned and what the config contributed, and the floor filters on the request alone: config can reorder candidates that already qualified, never invent one. Sourdough, Kubernetes, Lisbon weather and a hand plane all abstain now. Orbit's own flagship pitch reaches template-brain, which it always could, once it stopped being outscored by noise.
1 September 2026
A check that fails is useful. A check that passes without measuring is worse than no check, because you stop looking. Four of Orbit's shipped with that shape and all four are fixed here. orbit_check_email_auth graded a domain that does not exist in DNS, warning that no DKIM selector was found "among the 27 common defaults that answered": one fact about a missing zone, replayed 27 times and totalled as evidence. orbit_dark_mode_check returned pass on a composite whose logo it had never inspected, because img is self-closing and both of its colour walkers stepped straight over it. orbit_accessibility_lint caught a heading skipping forward and was blind to one dropping backward: absent from the issues, the passes and the not-measured list alike. And orbit_score_subject_line gave the README's best line and two deliberately generic ones the same 96/sharp.
1 September 2026
The manifest every installer agrees to promises Orbit "never sends prompts, queries, tool arguments". orbit_route_task posted your typed request to Orbit's server as part of a friction signal, and had done since the signal shipped. Redaction strips identifiers, not content, so a question about your own campaign travelled intact beside a persistent install id. That call is gone, and because deleting it only protects installs that update, the receiving server now reads the field and throws it away for every client, including every copy still on 0.32.0 or earlier. The rest of this release is the same shape: PRIVACY.md was never in the bundle at all, a consent audit was issuing passes to forms it had never actually checked, and a setup check could say blocked and go ahead in the same breath. 0.33.1 followed 0.33.0 by eighteen hours because the re-review found three false or vacuous claims inside the work written to stop false claims: including one of these fixes that had only been applied to one of the two surfaces it ships on.
31 August 2026
This is eleven days of finished work arriving at once: most of it built on 24 and 25 August and not reachable from an install until now. Two new read-only CDP integrations, Segment and RudderStack, join Amplitude and Databricks on the shared data family, which is why two platforms cost 455 bytes between them instead of two thousand each. A finished Stripo email now pushes as a real template into Braze, Iterable, Klaviyo, Mailchimp and Salesforce Marketing Cloud rather than Braze alone. orbit_create_braze_canvas can duplicate a live canvas. And the release carries one fix worth reading before anything else: orbit_check_email_auth had been reporting p=none DMARC as failing the Gmail and Yahoo bulk-sender rules. Both specs explicitly allow it. Acting on that advice meant a production DNS change that can quarantine your own legitimate mail.
20 August 2026
Orbit could fail you and you had no way to say so beyond closing the tab. Two new tools and one new telemetry signal fix that. Ask for a capability Orbit doesn't have and Claude can now offer to file it: orbit_submit_product_idea sends a feature request to Orbit's developer: composed with you, shown to you verbatim before it goes, redacted on your machine (emails, URLs, file paths, keys and number sequences are stripped before sending), never published anywhere, and retractable any time with the ref it hands back. Passively, Orbit now notices when things go wrong on their own: a tool that fails three times in a row, or a request that matched no skill at all, sends a friction signal: the only telemetry that carries any text, always redacted on-device first, and covered by the same one-variable opt-out as everything else.
13 August 2026
In Klaviyo, flows ARE lifecycle: welcome, abandoned cart, browse abandon and winback are all flows, not campaigns, and Orbit could read a Braze Canvas step by step while being blind inside a Klaviyo flow. orbit_klaviyo_flow_audit fixes that: the full step-by-step read, including the per-step leak table that shows where recipients fall out. Three widget surfaces ship alongside it: flow audit, revenue attribution and preheader clip. The rest of the release repairs a class of bug the review loop kept finding: checks that reported success while being wrong, from a 403 printed as zero sends to release gates that passed by asserting a string nothing emits any more.
13 August 2026
Five tools for the checks that are tedious enough to skip and expensive enough to regret. Ask Claude whether every campaign in your Braze workspace is measuring a conversion event that exists and fires: most workspaces have at least one that does not. Read your send calendar on the workspace's own clock and find the send scheduled inside quiet hours. Lint every preference centre against the 2024 Gmail and Yahoo bulk-sender rules, including the live page a subscriber lands on. Resolve every branch of a templated email and find the arm that no recipient will ever be shown. And emit the email as Gmail actually assembles it, so the render gate measures the delivered document rather than the one you wrote.
12 August 2026
The $249 licence, the Stripe checkout, the activation key and every entitlement check are gone from the extension. There is no account to make and nothing to enter: download the .mcpb, double-click it, and every tool works. The only thing that can still gate a tool is a credential for a platform you own (your own Braze key, your own Stripo token) sent only to that platform. The licence server the extension used to call on startup no longer exists, and neither does the code that called it. If you are on an older build, update: it will keep asking for a key nothing issues any more.
10 July 2026
Stripo's REST API documents a set of list and export endpoints Orbit had never used. We live-probed all of them against a real workspace, 11 of 11 work, and built five new tools on the results. You can now list and search your workspace's emails, read the full folder tree, list templates with the master template auto-discovered, export a finished email as compiled send-ready HTML, and read your plan's quota counters. Jobs that previously meant driving the Stripo cabinet UI by hand, or weren't possible at all. Setup gets sharper too: orbit_setup_stripo now verifies the master template's gen-area padding automatically and validates your REST token with Stripo's purpose-built /validate endpoint. Two cleanups round it out: the Stripo Default Folder ID setting is gone because nothing ever consumed it, and the module archived flag is now labelled as the unreliable signal it is, with the trustworthy check documented. 16 new tests; 423 pass.
8 July 2026
0.27.6 works through the write-path audit queue from the last release: the tools that create, update, or delete in Braze and Stripo now carry the overwrite-protection and idempotency checks that were flagged as missing. Two tools get more useful on their own terms: orbit_upload_images_to_braze takes a list of images in one call instead of one upload per round-trip, and orbit_get_stripo_email gains a body_mode switch so you can pull just the subject and structure of a large email without the full HTML weighing down the response. Setup messages that told Windows users to do something Mac-only now say the Windows equivalent. Five calculators had correctness bugs fixed: a contrast checker, an LTV warning threshold, a break-even case, a Liquid loop false-flag, and an ecommerce rate that could exceed 100%. Eight of the fixes and patterns from this cycle went back into the stripo-email-builder, braze-canvas-qa, and braze-claude-in-chrome-build skills so the same mistakes don't resurface. 407 tests pass.
8 July 2026
The MCP, Orbit running the work for you inside Claude, becomes $249, bought once, no subscription. Everything you learn from it stays free: the guides, the courses, the web tools, Orbit for macOS. Accounts that existed before this switch kept the MCP at no cost. Advice free, execution paid. That's the whole model.
19 June 2026
Most Stripo workspaces rot the same way. You build v1 of a template, then v2, then a quick fix, and now there are three near-identical copies: one in a folder, two loose at the root, and no clear signal which is current. The new stripo-library-cleanup skill does the housekeeping: it reads your whole library, groups emails by template, keeps the latest of each, and files loose root-level emails into the right (often nested) folders. Ask Orbit to "clean up Stripo", "dedupe Stripo", or "sort my emails into folders" and it inventories first, shows you a plan, and waits for your go before deleting anything: because Stripo deletes are permanent. It's the focused cleanup counterpart to the build-and-export work the stripo-email-builder skill already handles.
18 June 2026
Two new skills join the library. email-header-design runs a multi-agent loop that researches a brand from its live site, generates a hero image, and has a panel of design reviewers critique and re-prompt it until the design clears a quality bar: for the banner at the top of a marketing email. ip-warming does the maths for micro IP warming, spreading a one-time full-base send across several days so daily volume never spikes above what the IP's recent history earned, then shows you how to build it in Braze with Audience Paths, Random Bucket Numbers, and Delays, including the live Braze MCP method for pulling your trailing-30-day send volume when Braze exposes no single rollup for it. Alongside the skills, heavy Orbit tools are now easier to spot: in Claude Desktop they carry a branded chip title like "Orbit · Braze Sync", and their replies open with a concrete outcome line naming what Orbit did and the real result numbers, not just the closing signature.
16 June 2026
We narrowed what the Activation Key gates. Orbit's calculators, validators, email and template builders, diagram rendering, copy tools, and the full skill library now run without an account. A key is only needed when Orbit connects out to Braze, Stripo, Figma, or AI image generation. Plus a fix for keys that wouldn't take after pasting: fully quit Claude Desktop and relaunch so the change is picked up.
16 June 2026
From 0.24.0, Orbit asks for a free account before its tools will run. Create one at yourorbit.team, copy the Activation Key off your account page, and paste it into Claude Desktop: Settings → Extensions → Orbit → Activation Key. That's the whole thing. Orbit is free and stays free: no payment, no trial countdown, no card. The account exists so every user has a way to get product updates and support, not to put a wall in front of the product. Until a key is in, the tools that do real work stay locked and return a short note telling you exactly how to activate, but the diagnostics still run, so you can check your setup, check your version, and browse the full skill list while you sort the key out.
16 June 2026
Export a finished Stripo email to Braze through Orbit's bridge, send it for real, and in Outlook and some webmail clients it could arrive broken: buttons rendered as plain underlined links, padding collapsed. The same email exported with Stripo's own Export to Braze button rendered fine. We confirmed it with a live Braze test send: bridge export broken, native export correct. The cause was where the styling lives. Stripo returns an email's button look and spacing (background, padding, border-radius) in a separate stylesheet, not on the elements themselves, and the bridge folded that stylesheet into a single <head> style block. That renders correctly in clients that honour head styles, but Outlook and several webmail clients strip head styles on the way in, so the styling vanished and CTAs landed unstyled. Stripo's native export sidesteps this by writing the styling directly onto each element. The bridge now does the same: it inlines Stripo's styling onto the elements so it survives even where head styles get stripped, exactly matching what the native button produces.
15 June 2026
Hand orbit_delete_stripo_email or orbit_export_stripo_email_to_braze an array of email IDs, say all 36 in a program at once, and the call failed with Email IDs must be numeric Stripo email IDs. Got: "[...]". Single-ID calls were fine, so the only way through was 36 separate one-at-a-time calls. The cause was a stringified array: both tools accept a single ID or an array, and because the input is allowed to be a plain string, the desktop client is free to send your array as JSON text: [101, 102, 103] arrives as the literal string "[101, 102, 103]". The tool read that string as one ID, found it wasn't a number, and rejected the whole batch. Both tools now detect a JSON-encoded array or object and unwrap it back into a real list before validating, so the batch path works whether the client sends a real array or a stringified one.
9 June 2026
If a Stripo module paints a panel or gradient using a background image on a <table>, it looks perfect in the Stripo editor and then disappears once the email is exported and sent. Gmail, Outlook, and Braze's render all strip background images off <table> elements, but the identical image on a <td> survives. orbit_audit_stripo_modules now flags this directly, so you catch the silent fill-loss before it ships instead of after a test send, and the finding tells you exactly how to fix it.
9 June 2026
0.23.2 promised that re-exporting a Stripo email to Braze would update the same-named template rather than create a second copy. It didn't work. The name-dedupe step couldn't read your existing Braze templates, so it silently fell back to creating new ones: re-exports piled up duplicates, the exact thing the release was meant to stop. The cause was a one-line read bug: the template-list call returns a wrapper object and the dedupe code iterated the wrapper instead of its items. orbit_export_stripo_email_to_braze now unwraps the list correctly, so overwrite-by-name works as advertised.
9 June 2026
Re-exporting a Stripo email to Braze used to create a second copy unless you hand-fed it the template map from the previous run. Now it overwrites by default: before creating, orbit_export_stripo_email_to_braze lists your existing Braze templates and updates any whose name matches the email being exported, so running the same program twice leaves one clean template per email rather than a pile of duplicates.
9 June 2026
The Stripo-to-Braze export carried the email's HTML but not Stripo's separate stylesheet, so in Braze the call-to-action buttons fell back to plain underlined links and padding collapsed. Stripo returns a template's styling in two parts (the HTML document and a separate CSS field with the real button look, spacing, and mobile rules) and the export now folds that CSS into the template's head before it reaches Braze, so an exported email renders the way it does in Stripo's own preview.
8 June 2026
Once an email is built in Stripo, getting it into Braze meant opening each one in the Stripo editor and clicking Export to ESP, one at a time. orbit_export_stripo_email_to_braze does the whole batch in a single call: point it at one Stripo email ID or all forty-two, and each becomes a Braze email template a Canvas can reference. Under the hood it reads each email's rendered production HTML from Stripo and creates the matching Braze template; Liquid like {{custom_attribute.first_name}} carries through untouched, because Braze resolves it at send time, not Stripo. Re-run it and it updates the templates it made the first time instead of piling up duplicates. Stripo has no native export-to-ESP API, the GUI button is the only first-party path, so this reproduces what that button does, programmatically.
29 May 2026
Three new Stripo tools close gaps that turned up during a large email build. You can now read a pushed email back by ID, delete generated emails (one or many) without leaving Orbit, and check your Stripo connection before a push instead of finding out mid-send. The setup check now reports your Stripo credentials too.
29 May 2026
The fix shipped in 0.21.2 didn't hold: local image uploads to Braze still failed with the same 400. The real cause was the upload format: Braze's media library expects a local file as a binary upload, not as base64 data tucked inside a JSON request. orbit_upload_image_to_braze, orbit_upload_images_to_braze, and the Braze template image upload now send the file the way Braze expects, so uploads from a file path or raw base64 land in your media library and return a hosted CDN URL. Verified end to end against the live Braze API. Remote-URL uploads were never affected.
28 May 2026
This release attempted to fix local-file uploads to Braze (orbit_upload_image_to_braze and orbit_upload_images_to_braze), which were failing with a 400 reading "Either asset_url or asset_file must be provided". The change addressed the wrong cause and did not resolve the issue: uploads from a file path or raw base64 still failed. The working fix shipped the next day in 0.21.3. If you're on 0.21.2, update to 0.21.3 to upload local images successfully.
22 May 2026
Small but user-visible cleanup to how orbit_compose_stripo_email labels pushed emails in Stripo when you haven't supplied an email_name override. The auto-name used to read Orbit · <subject> · 2026-05-22T02-16-18-620Z: a full ISO timestamp with colons swapped for hyphens, useful for sub-second collision avoidance but unreadable in the Stripo email list. It now reads Orbit · <subject> · 2026-05-22. Scannable in the workspace, still distinguishable across days, and aligns with how program-variant labels (Welcome - Paid, M2 Phone Divert A - Starter) read in the same list. Scope is strictly the user-facing emailName written to Stripo: local workspace HTML filenames and the diagnostic probe scripts keep their full timestamps because the collision-avoidance reasoning still applies on disk. The email_name override parameter is unchanged, so callers passing program-variant names continue to land them verbatim.
21 May 2026
Two small additions to orbit_compose_stripo_email, both born out of running enough real Stripo pushes to feel the friction. First: an optional email_name argument. Pass email_name: "Welcome - Paid" (or whatever program-variant label makes sense) and that string is written to Stripo verbatim as the email's display name. Omit it and the existing Orbit · <subject> · <timestamp> auto-name still fires, but anyone running a real lifecycle program ends up renaming every pushed email in the Stripo UI to find anything later, so the override is the path you actually want. Square brackets are stripped defensively because Stripo's API rejects them in email names. Second: convention_warnings on the push response. Two non-blocking checks against the workspace's own brand-guidelines and email-design-conventions docs: em dashes anywhere in subject, preheader, email_name, or any nested slot_values text (recursive); and a hero H1 cap of one sentence and four words, scoped to the position-1 module's title slot so long titles on later modules don't false-positive. Warnings are advisory; the push still succeeds. Each warning carries rule, location, value, and a fix hint, so the assistant can self-correct on the next pass rather than wait for a human read-through.
15 May 2026
Three read-only additions aimed at the same job: auditing a Braze workspace against the source of truth that's supposed to feed it. Most lifecycle programs accrete custom attributes and segment filters faster than anyone documents them, and the drift between what the warehouse / PostHog / Stripe says and what's actually populated on Braze profiles is where personalisation quietly breaks. orbit_export_braze_user_by_id reads up to 50 raw user profiles by external_id and returns custom_attributes, custom_events, campaigns_received and the identity fields exactly as Braze stores them: pass-through, no QA-style filtering, so you can diff billingLifecycleState / planType / hasActiveSubscription against your warehouse and see where the wires crossed. orbit_read_braze_segment returns a single segment's full definition (name, description, filter logic, tags, analytics-tracking status) so segment targeting can be audited against canonical attribute names without clicking through the dashboard. And orbit_audit_braze_instance now surfaces the actual NAMES of custom events and custom attributes alongside the existing counts, so naming hygiene checks (case drift, plural-vs-singular, leftover test attributes) are one call instead of three. All three tools are read-only; none of them write to Braze.
14 May 2026
Two payloads in one release. The Stripo module-bindings inspector gains a half-pair drift check: catches a CTA where only one half of the text/link Smart Property pair is registered, leaving the other half hardcoded in the module HTML. This was a quiet authoring slip with loud production consequences: every compose call looked successful while shipping the master-template default for the unregistered half. Scope is gated to base names ending in cta / button / btn so image-as-link patterns don't false-positive, and an ACK comment marker is available for intentional half-pairs (split CTAs where one half is design-by-intent static). Separately, orbit_validate_braze_data now recognises Braze's 26 standard user-profile fields (first_name, country, time_zone, push_token, etc.) alongside your custom attributes, so it stops false-flagging well-known profile fields as missing. Each found attribute is now tagged with whether it's standard or custom and the exact Liquid syntax to use, so the assistant can stop guessing whether to wrap a name in custom_attribute. orbit_audit_braze_instance surfaces the same 26 standard fields alongside the custom inventory. And orbit_validate_test_users no longer 400s when you pass an array of email addresses: Braze's /users/export/ids endpoint quietly accepts an array of external_ids but only a single email_address per request, so the tool now loops emails serially. The expanded response surfaces every standard field's value plus populated / empty arrays per profile, so verifying "is first_name actually populating in this test profile?" no longer requires inspecting the raw user object.
14 May 2026
Three empirical probes against Stripo's REST API today confirmed what 0.19.6 onward had been narrowing toward: there is exactly one path that supports per-send content substitution on Stripo modules, and it's pushing variable values into modules marked up with esd-dynamic-block Smart Element bindings via the editor's Smart Elements wizard. Every inline-HTML push path (the legacy areas shape, dataSources inline html, PUT edit-after-push) fails, the first two silently. So 0.19.10 strips user-facing references to those dead paths and consolidates around the one that works. orbit_setup_stripo gains a new Step 4 that walks you through marking up your modules with Smart Element bindings before you ever try to compose against them. orbit_inspect_stripo_module_bindings now hand-holds you toward the Smart Elements wizard when it sees a module with no or few registered variables, rather than leaving you to guess what's wrong. The three Stripo probe tools (orbit_probe_stripo_values, orbit_probe_stripo_inline_html, orbit_probe_stripo_smart_element) get their descriptions reframed so it's clear which two are internal diagnostics confirming dead paths are still dead, and which one tests the production path. And the stripo-integration skill now opens with a Foundational requirement preamble so anyone loading the skill cold lands on the right path from sentence one.
14 May 2026
Three precision fixes to the Stripo module-bindings inspector after the 0.19.8 detectors landed and immediately produced false positives in real workspaces. The static-asset pattern check now counts a variable as image-bound only when its primary mapping targets the src attribute, so text variables with secondary alt/title mappings on an image element no longer pad the count and trigger the note. The wizard top-level link-field note now requires the module to actually contain a button-shaped element AND not already have an href binding registered against it, so modules with no button (or modules whose CTA href is already covered by a registered Smart Property) stop seeing a note they can't act on. And two HTML-comment patterns the skill already recommended are now read back by the inspector: paste the static-asset marker comment to silence the static-asset note for a module whose imagery is design-by-intent, or paste an ACK comment naming a specific variable and attribute to silence selector-without-target notes for bindings that are dormant on purpose. The skill doc gains the exact paste-ready snippets in a new Acknowledging static-asset intent subsection.
13 May 2026
Two new detectors land on orbit_inspect_stripo_module_bindings and orbit_audit_stripo_modules, both targeting Stripo authoring patterns that pass structural inspection, render fine in the editor, and then misbehave at compose time. First: the static-asset pattern. When a module registers three or more image variables all bound to src on esd-gen-image* class elements, the asset URLs are almost always design (tick markers, badge grids, brand-logo walls) not per-send content. The trap is that Stripo's Smart Element wizard auto-re-registers esd-gen-* classes every time the module is reopened in the editor, so deregistering from the Data tab doesn't stick. The fix is documenting which variables are static-by-design as an HTML comment at the top of the module, which the wizard leaves alone. The inspector flags the shape and tells you what comment to add. Second: nested selectors. When two Smart Property bindings target elements where one contains the other in the DOM, Stripo writes the outer binding by replacing the inner element wholesale at compose time, and the inner binding's value gets clobbered. Detection uses real DOM containment via Cheerio, not string matching. Both detectors fire in the single-module inspector and the bulk auditor, and the static-asset best practice is now in orbit_setup_stripo's onboarding instructions. Also in this release: a brand-name fallback fix so unconfigured workspaces no longer see a hardcoded value.
12 May 2026
0.19.6 made per-send substitution on Stripo modules work end-to-end. 0.19.7 is the follow-up that closes the loop on verification. A registered Smart Property can point at a CSS class hook that doesn't exist anywhere in the module's HTML: the variable accepts values at compose time, the API returns success, and substitution silently never fires. You only notice when the defaults ship in production. orbit_inspect_stripo_module_bindings now flags exactly this case per-variable, with the fix path inline. The stripo-module-bindings skill has been hardened around what the inspector still can't catch on its own: a pre-flight checklist before treating a binding as done, the end-to-end probe-email recipe that's the only honest way to confirm substitution actually fires, the canonical p_* naming table, and worked examples of three common silent-no-op patterns. The Stripo Modular MCP integration guide has been extended with the same probe-email procedure so anyone working from the docs can verify their bindings without loading the skill first.
12 May 2026
Two halves of the same release. First, the sync bug that was silently breaking every per-send substitution call is fixed. Smart Properties in Stripo carry two labels: a canonical API identifier (e.g. p_title) and a human label shown in the editor (e.g. Title), and Orbit's sync was storing the human label, so the compose validator kept rejecting correctly-formed payloads asking for p_title. The extractor now reads the API identifier, the CSS class hook gets persisted alongside it, and slot_values substitution works against the variable names Stripo's docs already tell you to use. Second, a new skill, stripo-module-bindings, walks you through the editor work that has to happen before any of this is useful. Registering a Smart Property in Stripo's UI has a load-bearing picker that's the same shape as a similar wrong option: pick the wrong one and the binding looks fine in the editor and is invisible to the API. The skill is the antidote: step-by-step registration, the verification check that catches the silent-failure mode, and a naming convention that matches Stripo's own.
11 May 2026
Hotfix to the orbit_inspect_stripo_module_bindings tool shipped yesterday in 0.19.3. The 'unmapped esd-gen-* classes' note used to infer the expected variable name from each CSS class, so a module that bound .esd-gen-title to a Smart Property called p_title (variable name doesn't match class basename, common in workspaces with a p_* naming convention) got falsely flagged as unmapped, with a follow-up instruction to register a variable that already existed. The inspector now cross-references actual blockMapping selectors instead of inferring names, so only genuinely orphan classes get flagged. CTA dead-end guidance also softened: no longer hardcodes cta_text / cta_href as the recommended names, since workspaces using a different prefix would get pushed toward names that conflict with their own convention.
11 May 2026
Two additions to the Stripo composer toolkit. orbit_compose_stripo_email now accepts the canonical-JSON content[] shape, so Smart Container modules, the layout shells with empty slots that host child modules per send, can be populated end-to-end from a single tool call. And a new orbit_inspect_stripo_module_bindings tool reports exactly what a given module accepts via the API: which Smart Properties are registered, which esd-gen hooks exist in its HTML, whether it looks like a Smart Container, and whether its CTA is bound to the editor's silent-fail OG-preview field. Pair the two: inspect first, then compose with the right shape.
11 May 2026
Stripo doesn't publish a stable contract for which field on GET /emails/<id> carries the rendered HTML, so the 0.19.1 html_overrides path was one response-shape quirk away from a silent miss. 0.19.2 fixes it with a two-source fetch chain: first the previewUrl that comes back on POST /email (public, full document, no JSON parsing), then the REST endpoint with a smart field scan that tries six likely names and auto-detects HTML by content when none match. Every failure path now returns fetch_source, html_length, html_excerpt and a typed list of response keys, so when something does miss the next debug round is one step instead of three.
11 May 2026
Stripo's write APIs for existing emails are a dead end. PUT and PATCH on /emails/<id> return 405, and the inline-html dataSources field that looks like it should let you override copy gets silently regenerated from the master template on every gen pass. So Orbit stops trying to write back. orbit_compose_stripo_email now accepts an html_overrides argument that fetches the Stripo-rendered email after push, Cheerio-patches the CTA text and href on every a.es-button element, and writes the patched HTML to disk for Braze sync. Stripo stays the source of structure; the per-send CTA variation happens client-side, after Stripo has done its job.
9 May 2026
Three new capabilities for the Stripo and Braze workflows. Smart Element modules can now have their slot content varied per send directly in orbit_compose_stripo_email: no manual Stripo work needed between sends. orbit_list_stripo_modules now shows which variables are bindable in each module so you know before you compose. And a new orbit_upload_image_to_braze tool uploads a single image from disk and hands back a Braze CDN URL ready to drop into any template or content block.
8 May 2026
Three customer-facing changes in this release. Anonymous usage telemetry is now on by default in the Orbit MCPB: until now we collected nothing unless you'd manually set ORBIT_TELEMETRY=1, so the dashboard was blind to which skills and tools were actually being used. We send only the skill or tool slug, the MCPB version, and an opaque per-install ID. Never your prompts, your tool arguments, or your IP. There's a new install-time checkbox to opt out, and ORBIT_TELEMETRY=0 still works. A new orbit_probe_stripo_values tool empirically tests Stripo's `values` field against your live workspace: the gating step before we ship slot-aware overrides on orbit_compose_stripo_email. And the slop detector now catches the 'There's a specific kind of [feeling] that comes from…' viral opener template.
8 May 2026
Production-test of orbit_compose_stripo_email on a multi-module welcome email surfaced four issues; this release fixes all of them. Multi-email briefs now build one at a time with an explicit gate between each. Push responses always make it back through Anthropic's 1 MB tool-result cap, so you can verify what landed instead of guessing. Copy and image overrides no longer silently disappear when push:true is set: the tool now refuses with a clear message rather than pushing the wrong content. And the master-template setup instructions now tell you to zero out the wrapping Structure's padding so pushed modules render flush with the canvas.
7 May 2026
When Orbit composed an email and showed the preview as a Claude artifact, all the placeholder images in your modules rendered as broken-image icons. Turns out Claude artifacts run inside an iframe with a strict CSP that blocks external img-src: Stripo's CDN was serving the images perfectly, the artifact just couldn't fetch them. Fix: orbit_sync_stripo_modules now downloads each module's images locally during sync, and orbit_compose_stripo_email inlines them as base64 data: URIs in the preview HTML. The preview now matches what the actual email looks like in your inbox. Images you push to Stripo still use the original CDN URLs (data: URIs never leave Orbit): Stripo composes server-side from its own copy of the module HTML.
7 May 2026
Awkward operational story worth being honest about: the four versions shipped today (0.18.7 Stripo native integration, 0.18.8 Braze fix, 0.18.9 Stripo audit/fix tools, 0.18.10 MCP server lifecycle fix) were all committed and pushed to GitHub, but none of them actually reached the .mcpb download because the CI build job had been failing since 27 April on a transitive-dependency audit gate. Discovered the failure when the website kept showing v0.18.5 despite 4 successful-looking pushes. 0.18.11 fixes the underlying CI break by bumping mjml to v5 (which removes the dead html-minifier dependency), and bundles every feature from those four prior versions into one deploy that actually lands.
7 May 2026
Until this release the Orbit MCP server didn't watch for the signals that mean 'your parent's gone, stop running.' The result was zombie server/index.js processes accumulating in the background after Claude Desktop quit: each burning 50–80% CPU, sitting around for days. Reliability fix: every shutdown signal now funnels into a single idempotent exit path, including a parent-alive watchdog for the rare case where stdio events don't fire. Routine fix; you'll notice it as 'Activity Monitor stops filling up with old Orbit processes.'
7 May 2026
The Stripo integration's push half is now live: orbit_compose_stripo_email with push:true creates a real email in your Stripo workspace from your synced module library, every time. Two new tools land alongside it: orbit_audit_stripo_modules catches a class of structural issues that emerge when you reuse modules across contexts (the lopsided-block bug being the most visible one), and orbit_fix_stripo_module returns the corrected HTML for paste-back into Stripo's module editor. Stripo's REST API is read-only for modules, so the fix is necessarily manual, but the audit catches everything programmatically, including a surprise gotcha around how Stripo's API references modules.
7 May 2026
The 0.18.6 changelog two days ago promised a fix for orbit_braze_performance reporting zeros on scheduled-blast canvases. Turns out the manifest version bumped but the underlying code never made it into the published .mcpb, so anyone who downloaded 0.18.6 (or 0.18.7 yesterday) still got the old broken behaviour. The actual code now ships in 0.18.8. If you saw the entry, downloaded the update, and noticed nothing changed: that's why. Sorry.
7 May 2026
Orbit now talks to Stripo's REST API. Connect once, and Orbit pulls every custom module you've saved, documents your modular design system as a markdown brief, and lets you compose on-brand emails from a sequence of modules: with an HTML preview rendered inline in Claude before you push the result back to your Stripo workspace as an editable email. The paste-driven Stripo flow still works; this is the API-driven sibling for users who want a tighter loop.
5 May 2026
orbit_braze_performance was returning zeros for canvases that use a scheduled audience instead of an action-based trigger, even when the canvas had clearly sent. The headline metric now rolls up sent / delivered / opens / clicks / unsubscribes / bounces directly from the Braze step rollup, so a 582-send blast reads as 582, not 0. When a canvas has message steps but the API gives back nothing, you'll see a warning instead of a silent zero.
30 April 2026
Two macOS app updates landed today. Orbit Dictation has been renamed Comet: same app, same shortcut, same menu-bar behaviour, on-theme name. Orion picked up a refreshed app icon (the Orbit planet plus AI sparkles), and the unsigned-app footer in install instructions was rewritten so it no longer claims Orion is 'the founder of Orbit' (he's the dock assistant, not the founder).
28 April 2026
The page that creates your free Orbit account moved from /download to /sign-up. Same form, same flow: the URL was misleading because the page is primarily account creation (which then unlocks the MCP server download, your tool history, course progress, and LinkedIn certifications), not a direct file download.
28 April 2026
Orbit (the .mcpb extension and every web tool) is now free for everyone. No flat fee, no purchase, no gate. Donations return as a separate, optional pay-what-you-want surface at /support: decoupled from getting Orbit.
28 April 2026
Orbit moves from pay-what-it's-worth to a single flat fee. $9.99 USD, one-time. Every future Orbit release is included on the same payment: no subscription, no upgrade tier. The free path stays exactly where it was for anyone who can't pay.
27 April 2026
Each row of the warm-up schedule now has a click-to-copy chip with a ready-made segment name like 'IP Warming Day 1 - RBN 0-90'. Build the schedule, copy the segment name for the day you're configuring, and paste straight into your ESP: no manual concatenation.
27 April 2026
Added a Year option to the date/time formats in the Liquid Syntax Generator. Outputs just the four-digit year (%Y): useful for footer copyright notices, anniversary messaging, and 'Year in review' content where the rest of the date is noise.
27 April 2026
Claude Desktop was falling back to a generic 'O' placeholder instead of the Orbit logo because the bundled icons were 1024×1024: larger than Claude Desktop's icon size cap. Resized to 512×512 (the size every working extension on the platform ships) and the logo renders correctly again.
27 April 2026
The Claim button now lives inline on the badges page itself. One click to issue the cert, watch the confetti, and the card flips to Earned in place: no more navigating to the course page just to hit Claim. The course-page Claim button also fires confetti now for consistency.
27 April 2026
If you claimed a course completion badge but came back to find the course had reverted to 'Ready to claim', the claim was succeeding in the UI but silently failing to save server-side under specific account conditions. Fixed: every claim now persists, every revisit shows your earned badges. Same fix also applied to quiz-pass and reading-progress saves so they can't fail silently either.
27 April 2026
Signed-in users now see a Recent names list under the Namer output. Save-on-copy persists the name plus the dimension selections, so a click on any history row repopulates the form for further editing. Up to 10 entries, oldest dropped first.
27 April 2026
Braze rebranded its generative AI layer from Sage AI to BrazeAI. Every reference inside the AI personalisation course (4 guides, course description, quiz pool) and the AI personalisation skill in the Orbit MCPB now uses the new name, with a 'formerly Sage AI' disambiguator on first mention so readers searching with either name still find the content.
26 April 2026
Seven-guide course on AI personalisation now ships as MCP resources, so Claude can cite each guide inline when AI personalisation comes up in conversation. Grounded in BrazeAI / Predictive Suite / Connected Content / Catalogs but speaks broadly across ESPs.
24 April 2026
Expanded the trigger surface so Orbit responds to every major lifecycle, deliverability, experimentation, compliance, and platform concept inside Claude, plus an explicit 'don't activate' list to prevent false positives outside the marketing domain.
24 April 2026
The fallback extension icon now has a transparent background, matching the light/dark theme variants already in the manifest. Cosmetic consistency fix: no functional change.
24 April 2026
A behavioural rewrite of Orbit's routing contract. Claude now walks users through getting the right inputs before tools run, cites the practitioner guides that informed each answer, and refers to the senior-operator layer as Orbit Intelligence when framing judgment or recommendations.
24 April 2026
Big polish + capability release. Six critical / major audit findings fixed (Stripo parser, contrast walker, SPF counter, replenishment ordering, dark-mode accuracy, exec-report escaping). Six new tools for pre-send QA, rendering, Postmaster parsing, list growth, GDPR audit, and A/B test readouts.
23 April 2026
Thirteen new tools + five new skills. DNS-level email auth checks, WCAG email lint, RFM scoring, cohort retention, preheader scoring, Liquid validation, SMS composer, free-shipping / replenishment / exec-report calculators, plus emergency and planning skills.
23 April 2026
Three new tools for persistent-memory email template workflows. Paste your existing HTML once, Orbit remembers its modules and brand tokens, and every future email gets built from the same modular system.
23 April 2026
Orbit now ships the full 9-course curriculum as MCP resources, so Claude can recommend the right course URL when a user's question has real training depth. orbit.md updated so Claude answers first and only surfaces a course when it materially expands on the answer.
22 April 2026
Downloads are now portal-only. The .mcpb moved off the public GitHub mirror to a private Railway-backed bucket. Unauthenticated requests to the download endpoint are redirected to sign in or create a free account.
22 April 2026
If you restart Claude Desktop between pausing a job and continuing it, Orbit now tells you so: plainly. Previously both "an hour passed" and "you restarted" surfaced as the same generic "expired" error.
22 April 2026
When an Orbit workspace audit pauses and resumes, the final result now carries the original call's timestamp: not the resume moment. A cosmetic fix that closes the last parity gap between uninterrupted and resumed runs.
22 April 2026
Braze performance pulls are fast again: 0.13.0 accidentally serialised per-ID fetches to enable resume, which slowed down the common case. Now processes 5 IDs in parallel with checkpoints between batches.
22 April 2026
Big Braze audits and performance pulls that previously hit the context limit now pause cleanly and offer to continue: no re-running, no lost work. Claude picks up exactly where it stopped when you say go.
22 April 2026
Tighter time budgets and response caps so tool calls land inside Claude Desktop's window, and when a tool does run out of time, Claude now offers you a Continue instead of breaking the conversation.
17 April 2026
Per-tool deadlines, response size caps, retry + circuit breakers, attribution signatures, artifact chrome, and the new orbit_check_version tool.
17 April 2026
20 audit findings resolved, full Braze region support, 58-test foolproof e2e test package, and a shared error classifier across all 54 tools.
16 April 2026
Standalone browser-based tools for Braze naming, email size checks, Liquid syntax, push previews, significance testing, IP warm-up, and percentage change.
16 April 2026
Full workspace-awareness for Braze: instance audit, canvas reader, performance data, segment analysis, template collision detection, and more.
7 April 2026
MJML templates, HTML compilation, cross-device previews, Figma import, brand kit intake, and Braze sync: the full email production loop.
31 March 2026
Initial release: Claude Desktop MCP extension with 50+ lifecycle marketing skills, program discovery, message planning, and lifecycle diagrams.