DEV Community: Saptarshi Paul

Stop Paying Per Seat: A 2026 Pricing Teardown of 10 Social Media Automation Tools

Saptarshi Paul — Tue, 06 Oct 2026 03:40:45 +0000

Most social media automation tools promise the same things on their landing pages: a visual content calendar, an AI caption assistant, suggested best times, and analytics reports. The real differences only surface when you dig into how they bill you, how well they support platforms like X and LinkedIn, and whether they can automatically recycle your best posts. To make this comparison concrete, we use a fixed example setup throughout: 3 social media accounts managed by a team of 3 people who draft, approve, and schedule posts together. We also show how costs scale when you go up to 8 accounts across different platforms. Depending on the tool, that 3-person team costs anywhere from $17 to $37 a month on Publer, $36 to $96 on Buffer, or up to $1,197 on Sprout Social.

Key Takeaways

Comparing tools with a realistic team setup matters. Managing up to 8 social accounts (including 3 LinkedIn profiles and 1 X account) with 3 people costs between $37 and $1,197 a month across these 10 tools.
Check what a plan includes before comparing base prices. Tools charge per channel, per social profile, per seat, or per brand, so the advertised starting price rarely tells the full story.
Publer ($37 to $63), SocialBee ($69), and Sendible ($70) are the cheapest options for this setup on monthly billing, and all three include X publishing at no extra cost.
Connecting X and multiple LinkedIn profiles often increases the price. Metricool ($10), Vista Social ($29), and Agorapulse ($29 to $69) charge extra per X account. Later dropped X support in August 2025. Connecting 3 LinkedIn profiles uses 3 separate brands on Metricool and Later.
Per-seat tools get expensive quickly. With 3 logins, monthly costs rise to $476 on Agorapulse, $597 to $1,197 on Hootsuite, and $1,197 on Sprout Social.

The 10 Tools at a Glance

All prices below are from each company's official pricing page as of 29 September 2026, using standard month-to-month billing without an annual contract. The third column shows what it actually costs a 3-person team (with post approval features) to manage up to 8 social media accounts across major networks: a LinkedIn company page, 2 personal LinkedIn profiles, X, Instagram, YouTube, TikTok, and Bluesky or Threads.

Tool	Starts at	8 accounts, 3 users, monthly	How the plan charges	X (Twitter)	Evergreen recycling
Publer	Free, then $5	$37 (Pro) or $63 (Business)	Per channel + $2 per extra user	Included	On Business
SocialBee	$29	$69	Profile pool + $10 per extra user	Included	Yes, category queues
Sendible	$35	$70 (2 Core) or $99 (Plus)	Workspaces and profile pool, unlimited users	Publishing only	Yes
Metricool	Free, then $25	$77 ($67 plan + $10 X)	Brands (1 account per network)	$10/mo add-on	Yes, Autolists
Buffer	Free, then $6/ch	$96 (8 x $12 Team)	Per channel, unlimited users on Team	Included	No
Later	$25	$70 to $110, no X	Social Sets (1 account per network) + users	Dropped Aug 2025	No
Vista Social	$99	$228 ($199 plan + $29 X)	Tier bundle of profiles and users	$29/mo add-on	Yes
Agorapulse	$99/user	$476 ($447 seats + $29 X Lite)	Per user seat (10 profiles shared)	$29 or $69/mo add-on	Yes
Hootsuite	$199/user	$597 (Standard) or $1,197 (Advanced)	Per user seat	Included	No
Sprout Social	$249/seat	$1,197 (3 x $399 Professional)	Per user seat	Included	ViralPost queue

Understanding Social Media Tool Pricing

The starting price on a pricing page is rarely what you will actually pay. These 10 tools use four different billing models.

Per channel: Buffer and Publer

Buffer and Publer charge per social account. Each connected account, whether it is a company LinkedIn page, a personal profile, or a TikTok account, counts as one channel. Buffer charges $6 per channel on Essentials for one user and $12 per channel on Team with unlimited users. Publer charges a base fee ($5 on Professional, $10 on Business) that includes the first channel and first user, then adds $4 or $7 per extra channel and $2 per extra team member. The bill grows as you add accounts.

Per brand or social set: Metricool and Later

Metricool and Later bundle accounts by network. A single brand or social set allows one account per network, like one LinkedIn, one Instagram, and one TikTok. This is cheap if you have one account per platform. But if you manage a company LinkedIn page plus two personal founder profiles, you need three brands or social sets, even if you do not use the extra slots.

Per profile pool: SocialBee, Sendible, Vista Social

These tools give you a fixed number of social profiles you can mix and match. SocialBee, Sendible, and Vista Social set a total profile limit. Sendible includes unlimited team members on every plan starting at $35. SocialBee charges $10 per extra user on smaller plans. Vista Social includes 2, 3, or 4 users depending on tier.

Per seat: Agorapulse, Hootsuite, Sprout Social

These tools charge full price for every login. Sprout Social's Professional plan is $399 per person per month. Three teammates on the same accounts cost $1,197, even though they share the same profiles.

X API fees add another cost

X (formerly Twitter) raised its API fees, and scheduling tools responded in four ways:

Buffer, Publer, SocialBee, Hootsuite, and Sprout Social include X publishing at no extra cost.
Sendible allows X publishing for free, but removed X analytics, inbox, and keyword monitoring in late 2023.
Metricool ($10/mo), Vista Social ($29/mo), and Agorapulse ($29 for X Lite publishing, $69 for X Plus with inbox and reporting) charge extra per X account.
Later dropped X support entirely on 28 August 2025.

The 10 Social Media Automation Tools

1. Buffer

Buffer is one of the simplest schedulers, and its pricing is straightforward: pay per channel. The Free plan allows 3 channels and 10 scheduled posts per channel. Essentials costs $6 per channel per month for one user. Team costs $12 per channel per month ($10 annually) and includes unlimited users and draft approval workflows.

For 3 accounts and 3 users on Team, you pay $36 a month. For 8 accounts and 3 users, it is $96 (8 channels at $12 each), with no extra charges for X or additional teammates. Buffer supports LinkedIn (company pages and personal profiles), X, Instagram, Facebook, TikTok, YouTube Shorts, Pinterest, Threads, Bluesky, and Mastodon. It added Bluesky, Threads, and Mastodon early, so it is popular with software teams.

Buffer does not have automated evergreen recycling. Once a post goes live, it leaves the queue. You can manually duplicate posts. RSS feeds can turn blog posts into drafts, and you can schedule first comments on Instagram and LinkedIn, but the comment inbox only works with Facebook and Instagram.

Pros: simple per-channel pricing, unlimited users on Team, Bluesky/Threads/X support with no add-on fee.
Cons: no evergreen recycling, comment inbox limited to Facebook and Instagram.
Pricing: free for 3 channels, then $6 or $12 per channel per month.

2. Publer

Publer also charges per account and per user, and it is one of the cheapest options for teams. Professional starts at $5/month for 1 account and 1 user, then adds $4 per extra account and $2 per extra user (every tenth account or user is free). Business starts at $10/month, adds $7 per extra account and $2 per extra user, and unlocks recycling, recurring posts, RSS auto-posting, approvals, and the API.

For 3 accounts and 3 users, Professional is $17/month and Business is $28/month. For 8 accounts and 3 users, Professional is $37 ($5 base + $28 for 7 extra accounts + $4 for 2 extra users). Business is $63. Both plans include X at no extra cost, plus LinkedIn pages and personal profiles, Instagram, Facebook, TikTok, YouTube, Pinterest, Threads, Bluesky, Mastodon, Telegram, and Google Business Profile.

Publer includes CSV bulk scheduling (up to 500 posts), automatic watermarks, link shortening, and first comments on Instagram, Facebook, LinkedIn, X, and YouTube. You can set rules to auto-share or delete posts after a set time. The main gap is community management: there is no unified inbox for DMs and support queries.

Pros: lowest cost for 3 accounts ($17 to $28) and 8 accounts ($37 to $63) with 3 users, $2 extra seats, X and Bluesky included, evergreen recycling and bulk scheduling.
Cons: no unified inbox, analytics only on Business.
Pricing: free for 3 accounts (excluding X), then from $5/month Professional (+$4 per account, +$2 per user) and $10/month Business (+$7 per account, +$2 per user).

3. SocialBee

SocialBee uses category-based queues to recycle content. You create folders (blog posts, product updates, customer quotes, industry news), set a weekly schedule per category, and SocialBee publishes posts in order. Mark a category as evergreen and it puts published posts back at the bottom of the list. You can attach multiple captions and images to the same post to vary it, or set expiration dates or share counts.

Plans are based on a profile pool. Bootstrap is $29/month for 5 profiles and 1 user. Accelerate is $49/month for 10 profiles and 1 user. Pro25 is $99/month for 25 profiles, 3 users, and 5 workspaces. Extra users cost $10/month each on Bootstrap and Accelerate. A 3-person team with 3 accounts fits on Bootstrap plus 2 extra users for $49. An 8-account setup fits on Accelerate plus 2 extra users for $69 (or Pro25 at $99). X, LinkedIn, Instagram, TikTok, YouTube, Threads, and Bluesky are included without extra platform fees.

Reviewers on G2 praise SocialBee for support and time savings, but note that initial setup of categories and schedules takes more effort than a simple calendar.

Pros: strong evergreen queues and post variations, flexible profile limits, X and Bluesky included, affordable $10 user add-ons.
Cons: setup is more involved, social inbox is basic compared to Agorapulse or Sprout Social.
Pricing: $29, $49, or $99/month for 5, 10, or 25 profiles; extra users $10/month each.

4. Metricool

Metricool combines scheduling, a unified inbox, competitor tracking, ad reporting (Google Ads, Meta Ads, TikTok Ads), and Looker Studio integration. Plans are structured around brands. One brand connects one account per network: one LinkedIn, one Instagram, one TikTok, one YouTube, one Threads, one Bluesky.

Starter is $25/month for up to 5 or 10 brands, but only one login and no approvals. Advanced is $67/month ($53 annually) and includes up to 15 brands plus team permissions. If you manage 3 LinkedIn accounts, you need 3 brands because each brand holds one LinkedIn connection. Advanced has room for that. Metricool charges $10/month extra per X account, so a 3-person team with X costs $77/month.

Autolists work like SocialBee's queues. You can add posts manually, via CSV, or from RSS, and set them to repeat. The inbox collects comments and DMs from Instagram, Facebook, TikTok, YouTube, LinkedIn, and Google Business Profile. This is a solid choice if you need detailed analytics, Looker Studio reports, and recurring lists under $80/month, but managing multiple LinkedIn profiles across separate brands is awkward.

Pros: Autolists for recurring queues, detailed analytics with Looker Studio on Advanced, unified inbox across 6+ networks, generous free plan.
Cons: one account per network per brand splits multiple LinkedIn profiles across workspaces, X costs $10/month per account.
Pricing: free for 1 brand (no LinkedIn or X), Starter from $25/month (1 user), Advanced from $67/month for 15 brands and team access, plus $10/month per X account.

5. Sendible

Sendible recently changed its pricing: every plan now includes unlimited users. It charges based on workspaces and total profiles. Core is $35/month for 1 workspace and up to 6 profiles. Plus is $99/month for 3 workspaces and 18 profiles. Premium is $199/month for 7 workspaces and 42 profiles.

A 3-person team with 3 to 6 accounts fits on the $35 Core plan with no extra user fees. For 8 accounts, you can add a second Core workspace for another $35, giving 12 profiles for $70 total, or upgrade to Plus at $99 for 18 profiles. All 3 teammates get access at no extra cost.

Sendible includes Smart Queues for evergreen recycling, RSS auto-posting, bulk CSV imports, UTM tracking, and client dashboards for external review without a full login. The main limitation is X: publishing is free, but X analytics, inbox, and keyword tracking were removed when X raised API prices. If you only need to publish to X and manage comments on LinkedIn, Instagram, Facebook, TikTok, and YouTube, Sendible is a reliable option.

Pros: unlimited users on every plan, Smart Queues, RSS auto-posting, easy client approval links.
Cons: X is publishing only (no analytics or inbox), no Bluesky support yet.
Pricing: $35, $99, $199, or $299/month for 6, 18, 42, or 90 profiles, all with unlimited users.

6. Vista Social

Vista Social moved from per-profile pricing to fixed tiers. Professional is $99/month ($79 annually) for 15 profiles and 2 users. Advanced is $199/month ($159 annually) for 30 profiles and 3 users. Scale is $449/month for 70 profiles and 4 users.

Because Professional only allows 2 users, a 3-person team must upgrade to Advanced at $199/month regardless of account count. Vista Social also charges a mandatory $29/month add-on for X. That brings a 3-person team with X to $228/month.

In return, you get one of the most complete feature sets outside enterprise contracts. It supports LinkedIn, Instagram, Facebook, TikTok, YouTube, Pinterest, Threads, Bluesky, Reddit, Snapchat, Tumblr, and Google Business Profile. It can manage customer reviews on Google, Yelp, TripAdvisor, and Trustpilot. You can schedule first comments on Instagram, Facebook, LinkedIn, YouTube, and TikTok, set up evergreen queues, and publish from RSS. It also includes Instagram and Facebook DM automation, so you can auto-reply with a link when someone comments a keyword, replacing a separate ManyChat setup.

Pros: built-in comment-to-DM automation, Reddit and Bluesky support, first-comment scheduling on 5 networks, unified inbox with review sites.
Cons: 3 users forces the $199 plan, X costs an extra $29/month.
Pricing: $99, $199, or $449/month for 15, 30, or 70 profiles and 2, 3, or 4 users, plus $29/month for X.

7. Later

Later started as an Instagram visual scheduler, and that still shows. It organizes accounts into social sets, each set containing one account per platform (Instagram, Facebook, LinkedIn, TikTok, YouTube, Pinterest, Threads, Snapchat), and limits users per plan. Starter is $25/month for 1 set and 1 user, with a 30-post-per-profile monthly limit. Growth is $50/month for 2 sets and 2 users (150 posts per profile), with extra sets at $15 and extra users at $5. Scale is $110/month for 6 sets, 4 users, and unlimited posts.

The big issue: Later dropped X support entirely on 28 August 2025. If you post to X, you need another tool. For other channels, a 3-person team with 3 accounts on different networks can use Growth plus 1 extra user for $55/month. To connect 3 LinkedIn profiles in an 8-account setup, you need 3 social sets, which brings Growth (with 1 extra set and 1 extra user) to $70/month, or Scale at $110/month for unlimited posting.

Later has no evergreen recycling or RSS auto-posting. Its strengths are visual planning for Instagram and TikTok, creator campaigns, Linkin.bio landing pages, and media libraries. It suits visual consumer brands that focus on Instagram, TikTok, and YouTube and have no X requirement.

Pros: visual Instagram grid preview, Linkin.bio landing pages, affordable $5 extra users on Growth.
Cons: no X support, one account per network per social set, post limits on Starter and Growth, no evergreen or RSS.
Pricing: $25, $50, or $110/month for 1, 2, or 6 social sets and 1, 2, or 4 users.

8. Agorapulse

Agorapulse charges per seat and targets mid-sized teams that spend a lot of time replying to comments and messages. Every plan includes 10 shared profiles and charges per login. Standard is $99/user/month ($79 annually). Professional is $149/user/month ($119 annually) and adds approval workflows, shared calendars, and inbox assignment. Advanced is $199/user/month ($149 annually) and adds automated inbox rules, bulk publishing, shared evergreen queues, and Google Analytics revenue reports.

For a 3-person team with approvals, you need 3 Professional seats: $447/month, whether you connect 3 or 8 profiles. Agorapulse also charges per X account: $29/month for X Lite (publishing only) or $69/month for X Plus (inbox and reporting). That makes the total $476/month with X Lite, or $516 with X Plus.

The price buys the Social Inbox and ROI reporting. Agorapulse collects comments, paid ad comments (Meta and TikTok), brand mentions, and DMs in one inbox. It shows live alerts when another teammate is viewing or replying to a message. On Advanced, you can set rules to hide, delete, tag, or assign messages by keyword, and track which posts drive visitors, leads, and sales in Google Analytics 4.

Pros: excellent social inbox with ad comment moderation, GA4 traffic and revenue tracking, evergreen queues, first-comment scheduling.
Cons: per-seat pricing ($149/user on Professional) plus $29 or $69/month per X account makes a 3-person team $476 to $516/month.
Pricing: $99, $149, or $199/month per user (with 10 shared profiles), plus $29 or $69/month per X profile.

9. Hootsuite

Hootsuite is the oldest platform here, and its pricing targets mid-sized and large organizations. On monthly billing, Standard is about $199/user/month ($99 annually) and covers up to 10 social accounts. Advanced is about $399/user/month ($249 annually) and supports unlimited accounts, custom approval workflows, automated inbox routing, and bulk scheduling for up to 350 posts.

For 3 people, Standard is about $597/month. If you need formal approvals, Advanced costs about $1,197/month ($747 annually). Unlike Agorapulse and Vista Social, Hootsuite includes full X support in standard plans with no extra add-on.

Hootsuite's edge is integrations. Its app directory has over 150 business tools, including Salesforce, HubSpot, Slack, Microsoft Teams, and Asana. It includes OwlyWriter AI for captions and repurposing top posts, plus basic social listening and automated DM replies. On the downside, reviews on G2 and Reddit frequently mention steep renewal price increases, pressure to sign annual contracts, and a dashboard that feels slower and more crowded than newer tools like Buffer or Publer.

Pros: X support included, 150+ enterprise integrations, social listening and inbox routing on Advanced.
Cons: high monthly cost ($199 to $399/user), no evergreen category queues, approvals require the expensive Advanced tier.
Pricing: about $199 or $399/user/month on Standard or Advanced ($99 or $249 annually), custom Enterprise pricing.

10. Sprout Social

Sprout Social is built for large corporate teams, customer support departments, and regulated industries. Every plan is per seat. Standard is $249/seat/month ($199 annually), limited to 5 social profiles and no approval workflows. Professional is $399/seat/month ($299 annually) with unlimited profiles, custom approvals, competitor reports, and ViralPost scheduling. Advanced is $499/seat/month ($399 annually) with automated inbox rules, a chatbot builder, and sentiment analysis.

A 3-person team with 3 accounts and no approvals can use Standard: $747/month. But if you need approvals or 8 accounts, you need Professional, which costs $1,197/month for 3 seats ($897 annually). X publishing, inbox, and reporting are included in the base price.

You pay $1,197/month because Sprout Social reliably handles large teams and customer care workflows. The Smart Inbox integrates with Salesforce Service Cloud, Zendesk, and HubSpot, so a complaint on X or Instagram can become a tracked support ticket. The analytics reports are executive-ready without extra formatting. Permissions let large orgs control exactly who can draft, approve, and publish across regions or brands. For a small 3-person team, though, you are paying roughly 15 times more than SocialBee or Metricool for enterprise features you may never use.

Pros: unlimited profiles on Professional and up, Smart Inbox with Zendesk and Salesforce integration, presentation-ready reports, X support included.
Cons: $399/seat/month ($1,197 for 3 users on Professional), Standard capped at 5 profiles, Social Listening and Employee Advocacy require paid add-ons.
Pricing: $249, $399, or $499/seat/month on Standard, Professional, or Advanced ($199, $299, or $399 annually).

Also Worth a Look

Five specialized tools did not make the main list because they focus on one piece of the puzzle. Typefully ($19/month Creator, $49/month Team) is a clean writer and thread scheduler for X, LinkedIn, Threads, and Bluesky. It can auto-post a follow-up comment with your link once a post reaches a like threshold. Taplio ($39 to $199/month) is built for LinkedIn personal brands and founder-led sales, with a searchable library of high-performing LinkedIn posts and lead lists from engagement. Planable ($39/month for 4 pages, $59 for 10 pages, unlimited users) is for creative agencies that need client sign-off with feed previews and multi-step approvals. Loomly ($65/month for 12 accounts and 3 users on monthly billing, or $49 annually) gives small marketing teams a shared calendar with approval alerts in Slack and Microsoft Teams. FeedHive ($19 to $99/month) helps creators set up automated follow-up comments that trigger when a new post performs well in its first hour.

How to Test and Choose

Start with two tools that fit your budget and workflow.

For under $100/month with 3 users and X included, look at Publer ($17 to $28 for 3 accounts, $37 to $63 for 8) for the lowest cost and bulk scheduling, Buffer ($36 for 3, $96 for 8) for the simplest calendar with unlimited users, SocialBee ($49 to $69) or Metricool ($77) for evergreen queues, or Sendible ($35 for up to 6 accounts, $70 to $99 for 8+) if you need unlimited logins.
For built-in Instagram comment-to-DM automation and review management on Google, Yelp, and Trustpilot, consider Vista Social ($228/month for 3 users with X).
If your team lives in a busy social inbox, moderates paid ad comments, and tracks revenue in Google Analytics, choose Agorapulse ($476/month for 3 users with X Lite).
For enterprise Salesforce or Zendesk integration, strict permissions, and unlimited profiles, go with Sprout Social ($1,197/month for 3 Professional seats).

Every tool looks smooth in a sales demo with sample data. You only see real limitations after connecting your own accounts. Test your top two choices with one full week of real posts before cancelling:

Connect your most important accounts first, including a company LinkedIn page, a personal LinkedIn profile, an Instagram business account, and an X account. Check whether they fit in one workspace, or if multiple LinkedIn accounts force separate brand folders.
Schedule a test post with a link in the first comment and a tag on another company page for LinkedIn and Instagram. Some schedulers drop personal profile tags or post first comments late. Check the live post on your phone.
Add 5 timeless posts to an evergreen queue and connect your RSS feed. Watch how the tool pulls in blog post titles, featured images, and tracking links.
Ask a teammate to edit a draft and mark it approved. Make sure the tool locks approved posts or requires re-approval after edits.
Calculate your true monthly cost: every social channel, every founder profile, any X fee, and every login.

Keeping a consistent publishing schedule also matters for AI search visibility. Ahrefs studied 75,000 brands across ChatGPT, Gemini, and Google AI Overviews and found that brands mentioned frequently on YouTube and across the web were recommended more often by AI engines. Sharing product videos on YouTube, joining discussions on Reddit and X, and posting clear guides on LinkedIn puts useful information on the pages AI models read. Once your social schedule runs smoothly, you can use Lumirank to track how often ChatGPT, Gemini, Perplexity, Copilot, and Google AI Overviews mention and cite your brand each day, starting with a free plan for up to 10 prompts.

Reference

Top 10 Social Media Automation Tools in 2026

Don't Buy an All-in-One AI Subscription Without Running These Checks

Saptarshi Paul — Tue, 06 Oct 2026 03:16:17 +0000

The landing page looks compelling. A dozen tools, familiar model names, a fair price. But that page is marketing copy, not a description of how the tool fits into your weekly workflow. A plan can look great in a screenshot and still be a poor match for your actual daily work.

That gap matters now because AI is no longer a single-task tool. Developers use it to review notes, compare options, dig through data, sketch outlines, and push out a first draft faster. A subscription worth paying for should slot into the way you already work, not force you to adopt a new process just to use it.

Summary

Before you buy an all-in-one AI subscription, check it against your real workflow instead of the feature list: confirm what's included, run it on tasks you'd do this week, judge the output on its own merits, read the usage limits, check team access and billing, and look at what the tool does with your data. If it clears those checks, it's probably worth the money.

Check what is actually included

Don't assume every AI subscription bundles the same stuff. Some are built around writing. Some give you access to a handful of different models. Others throw in tools for presentations, research, summarization, document review, or image generation.

Make a short list of what you actually need help with this month: research, planning, writing code, drafting support replies, building slide outlines, or getting through a long document. Then hold that list against what the subscription actually offers.

If most of the features line up with real tasks, the plan is probably worth it. If the tool list sounds impressive but doesn't touch what you do day to day, you're paying for a dashboard you'll open twice.

Test it against real work

The best way to test it is with something you'd normally be working on, not a sample prompt from a demo video.

Feed it a document you actually need to read this week. Ask it to compare two product ideas you're weighing. Hand it a pile of messy meeting notes and see what comes back. Try it on the task that usually eats an hour and see if the result saves you any of that hour.

That tells you far more than a features page ever will. A tool only earns its subscription fee if it holds up on real input, under normal conditions, not on the cherry-picked examples in a marketing email.

Review the quality of the output

Good output should be usable without a rewrite. It shouldn't read generic, shouldn't invent details you never gave it, and shouldn't create more editing work than it saves.

While you're testing, ask a few concrete questions: does it follow the actual request? Does it get the structure right? Does it avoid padding the answer with filler? Can you lift part of it straight into your work, or does everything need reworking? These questions get easier to answer when you can run the same prompt through more than one model and compare. That's the real argument for an AI tools subscription that puts ChatGPT, Claude, Gemini, and Grok behind one dashboard: you can put the same input in front of all four and see which one actually gets the structure, tone, and depth right, instead of judging a single model in isolation.

For anything research or decision related, check how careful the answer is. AI can sound confident while being wrong or incomplete. If it cites sources, open them. If it gives you a recommendation, ask it why. A tool worth paying for should sharpen your thinking, not just hand you polished-sounding text.

Look at usage limits

Usage limits are easy to skim past and expensive to hit. Some plans cap the number of messages, documents, models, uploads, or image generations you get. Others just throttle you after a burst of heavy use.

This matters if you're actually going to use the thing regularly. A light user might never notice a limit exists. A team running AI through their daily workflow can hit it by Wednesday.

Check the limits against how you'd actually use the plan before you buy. If you're buying for a team, look at the per-seat limits, not just the account-wide number, and check whether going over means a bigger bill next month.

Think about team access

If more than one person is going to use the subscription, access matters as much as the AI itself. Can you add people without a hassle? Does everyone get their own login, or is it one shared account? Is billing straightforward? Can you pull access the day someone leaves?

These sound like boring admin questions until they're not. A shared password, everyone's chat history mixed together, and no clear owner is a mess waiting to happen once AI becomes part of the daily routine.

A subscription that's actually built for teams lets people use the tools without creating a tangle around accounts, files, or who's paying for what.

Check how it handles your workflow

Look at how the tool fits into an actual day. Can you get into a task quickly? Can you move between different AI features without losing your place? Can you save work and come back to it later? Does the dashboard feel like something you'd open without thinking twice, or does it need a mental run-up every time?

The best subscription usually isn't the one with the longest feature list. It's the one people keep using a month in because it doesn't get in the way.

Review privacy and data settings

Any tool that touches work information deserves a privacy check before it touches anything else. Look at what kind of data you can enter, how uploaded files are handled, whether chats get saved by default, and what controls you actually have over that.

This matters even more for teams working with client details, internal plans, financial numbers, or anything unpublished. Not every task belongs in an AI tool, and it's worth knowing where that line is before employees start using the subscription on their own.

Make the decision practical

Don't buy an AI subscription just because the tool list is long or the monthly price looks low. Buy it because it solves something you're actually dealing with.

A subscription worth keeping should cut down on switching between tools, save time on tasks you repeat often, improve how you prepare work, or give your team easier access to AI support that doesn't require a new process to use. If it does one or more of those, it's probably worth the cost.

The review itself doesn't need to be complicated. Run it on real tasks, check the limits, look at team access, and make sure the tools actually match what you do. If a subscription clears those checks, you can buy it with a lot more confidence than the landing page alone would give you.

Reference

How to Review an All-in-One AI Tools Subscription Before You Buy

Don't Buy an All-in-One AI Subscription Without Running These Checks

Saptarshi Paul — Tue, 06 Oct 2026 02:46:26 +0000

Summary

Check what is actually included

Test it against real work

The best way to test it is with something you'd normally be working on, not a sample prompt from a demo video.

Review the quality of the output

Good output should be usable without a rewrite. It shouldn't read generic, shouldn't invent details you never gave it, and shouldn't create more editing work than it saves.

Look at usage limits

This matters if you're actually going to use the thing regularly. A light user might never notice a limit exists. A team running AI through their daily workflow can hit it by Wednesday.

Think about team access

A subscription that's actually built for teams lets people use the tools without creating a tangle around accounts, files, or who's paying for what.

Check how it handles your workflow

The best subscription usually isn't the one with the longest feature list. It's the one people keep using a month in because it doesn't get in the way.

Review privacy and data settings

Make the decision practical

Don't buy an AI subscription just because the tool list is long or the monthly price looks low. Buy it because it solves something you're actually dealing with.

Reference

How to Review an All-in-One AI Tools Subscription Before You Buy

Don't Buy an All-in-One AI Subscription Without Running These Checks

Saptarshi Paul — Tue, 06 Oct 2026 02:09:30 +0000

Summary

Check what is actually included

Test it against real work

The best way to test it is with something you'd normally be working on, not a sample prompt from a demo video.

Review the quality of the output

Good output should be usable without a rewrite. It shouldn't read generic, shouldn't invent details you never gave it, and shouldn't create more editing work than it saves.

Look at usage limits

This matters if you're actually going to use the thing regularly. A light user might never notice a limit exists. A team running AI through their daily workflow can hit it by Wednesday.

Think about team access

A subscription that's actually built for teams lets people use the tools without creating a tangle around accounts, files, or who's paying for what.

Check how it handles your workflow

The best subscription usually isn't the one with the longest feature list. It's the one people keep using a month in because it doesn't get in the way.

Review privacy and data settings

Make the decision practical

Don't buy an AI subscription just because the tool list is long or the monthly price looks low. Buy it because it solves something you're actually dealing with.

Reference

How to Review an All-in-One AI Tools Subscription Before You Buy

Bypass CGNAT: Reach Your Home Server or Raspberry Pi from Anywhere

Saptarshi Paul — Fri, 02 Oct 2026 14:37:07 +0000

You configured a home server or Raspberry Pi, forwarded a port on your router, and tested it from your phone's mobile data. Nothing loads. The router rule, firewall, and service all check out. The problem might not be on your side.

If your ISP uses Carrier-Grade NAT (CGNAT), your router never gets a publicly reachable IP address. No router setting fixes that. This guide explains how to confirm CGNAT, why port forwarding fails, and how to reach your server anyway.

Summary

If your router's WAN IP does not match the public IP from a "what is my IP" search, or it sits in 100.64.0.0/10, your ISP uses CGNAT and no port forward will ever receive traffic. The workaround is an outbound tunnel. Run ssh -p 443 -R0:localhost:8080 free.pinggy.io on the Pi to get a public HTTPS URL, or ssh -p 443 -R0:localhost:22 tcp@free.pinggy.io to expose its SSH port. Run that as a systemd service so it survives reboots, and lock down SSH before exposing anything.

What is CGNAT and why does it break home hosting?

Your home router uses NAT to let all devices share one public IPv4 address. IPv4 space is scarce, so many ISPs, especially mobile, satellite, and fixed-wireless providers, add a second NAT layer inside their own network. That is CGNAT.

With CGNAT, hundreds of customers share a single public IP. Your router gets a private address from the ISP, and the ISP translates it outbound. That works for browsing and streaming because your devices initiate connections. It fails for hosting because inbound connections cannot reach your router. The public IP belongs to the ISP, and there is no rule forwarding traffic to you.

In practice, CGNAT causes:

Self-hosted websites, dashboards, and home automation panels unreachable from outside
SSH to a Raspberry Pi only working on your local network
Game servers, media servers, and cameras inaccessible remotely
Webhooks failing to reach a home service

How to check whether you are behind CGNAT

Confirm it in about two minutes.

Find your router's WAN IP. Log in to your router admin page (often 192.168.1.1 or 192.168.0.1) and look for the WAN or Internet IP on the status page.
Find your public IP. Search "what is my IP" from any device on your network.
Compare. If they match, you have a public IP and ordinary port forwarding should work. If they differ, you are almost certainly behind CGNAT.

A WAN address in 100.64.0.0 to 100.127.255.255 (100.64.0.0/10, the shared address space for carrier NAT) is a strong indicator. WAN addresses starting with 10., 172.16. through 172.31., or 192.168. also point to an extra NAT layer.

Why traditional port forwarding fails under CGNAT

The usual approach is to open a port on your router and point it at your server. A common variant is SSH port forwarding, where you route traffic through an SSH connection to reach a service on another machine. Both require a publicly reachable address somewhere in the path that can accept inbound connections.

Under CGNAT, you do not control that address. Your router cannot open a port on an IP it does not own, so the forwarding rule never sees traffic.

Your options for reaching a server behind CGNAT

Ask your ISP for a public IP. Some assign one, often for a monthly fee. Worth a support call, but not always available.
Use IPv6. If your ISP and the connecting device support it, IPv6 needs no NAT. Many home networks still lack end-to-end IPv6.
Rent a VPS and build a reverse tunnel. Full control, but you provision, secure, and maintain the server yourself.
Use an overlay networking tool like Tailscale. Great for private access between your devices, but not designed for giving the public a URL.
Use a managed tunneling service such as Pinggy. Your server connects outward to a public endpoint, and traffic flows back through that connection. Nothing to rent or maintain.

The last option works because CGNAT only blocks inbound connections. Outbound connections pass through, so a tunnel that starts inside your network goes straight out.

How reverse tunneling gets around CGNAT

A reverse tunnel flips connection direction. Instead of the internet trying to reach your Pi, your Pi opens an outbound SSH connection to a server with a public address. That server relays incoming requests back through the same connection.

Because the connection starts inside your network, CGNAT treats it like any other outbound traffic. Pinggy is built on this mechanism. It runs the public-facing side, so you do not have to run your own server. For more detail, read Pinggy's guide to SSH reverse tunneling.

Step-by-step: access your Raspberry Pi with Pinggy

Every modern Linux, macOS, and Windows system includes an OpenSSH client, so there is nothing to install. These steps use a Raspberry Pi, but they work for any Linux home server.

Step 1: Enable SSH on your Pi

On the Pi itself, with a keyboard and screen or over your local network, enable SSH:

sudo raspi-config

# Interface Options -> SSH -> Enable

Before exposing anything, disable password logins and use key-based authentication. Copy your public key to the Pi first (ssh-copy-id does it in one command), or you will lock yourself out. Then edit /etc/ssh/sshd_config, set PasswordAuthentication no, and restart the service:

sudo systemctl restart ssh

Step 2: Tunnel a web service (HTTP)

If your Pi runs a web app, dashboard, or API, run this on the Pi, replacing 8080 with the port your service uses:

ssh -p 443 -R0:localhost:8080 free.pinggy.io

Pinggy prints a public HTTPS URL, like https://xxxx.run.pinggy-free.link. Open it from any network, including your phone on mobile data, and you will see your service. No router changes needed. The Pinggy documentation covers the same flow for different setups, and the Raspberry Pi tunnel tutorial goes into more Pi-specific services.

Step 3: Reach the Pi over SSH (TCP tunnel)

To log in to the Pi remotely, create a TCP tunnel to its SSH port (22):

ssh -p 443 -R0:localhost:22 tcp@free.pinggy.io

Pinggy returns a hostname and port. From your laptop, connect with:

ssh -p <PORT> pi@<HOSTNAME>

Replace pi with your Pi's username and use the hostname and port from Pinggy's output. The same approach is described in Pinggy's guide to accessing an IoT device over SSH from anywhere, which also covers other single-board computers such as Orange Pi, Banana Pi, and Jetson Nano.

Step 4 (optional): Use the Pinggy CLI

If you prefer a purpose-built client to typing SSH flags, the Pinggy CLI lets you set the tunnel type (http, tcp, tls, or udp), the local port, and the web debugger port with descriptive options. The SSH tunnel from step 3 becomes pinggy --type tcp -l 22.

Keeping the tunnel alive

A tunnel started in a terminal dies when the session closes, and the free plan has a 60-minute time limit per tunnel. Free tunnels also get a new URL each time. For a home server you want to rely on, plan for two things:

Auto-restart. Run the tunnel as a systemd service with Restart=always, so it reconnects after network drops or a reboot. Use ServerAliveInterval=30 in your SSH options to keep the connection healthy.
A stable address. Persistent URLs and custom domains are part of the Pro plan, so check current Pinggy plans if you need a permanent address.

A minimal service file looks like this. Use the exact command that works in your terminal:

[Unit]
Description=Pinggy tunnel to local SSH
After=network-online.target
Wants=network-online.target

[Service]
User=pi
ExecStart=/usr/bin/ssh -p 443 -R0:localhost:22 -o ServerAliveInterval=30 -o ExitOnForwardFailure=yes YOUR_TOKEN+tcp@free.pinggy.io
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Save it as /etc/systemd/system/pinggy-tunnel.service and start it with sudo systemctl enable --now pinggy-tunnel.

Security checklist for anything you expose

Making a device reachable from anywhere also makes it a target. Before you rely on a tunnel:

Use SSH keys, not passwords, and disable root login.
Add authentication to web services. Put basic auth or a login in front of dashboards and admin panels. Pinggy can add basic auth at the tunnel itself by appending -- b:user:pass to the command.
Use TLS tunnels when privacy matters. Pinggy's web debugger reads HTTP traffic to work. TLS tunnels keep traffic end-to-end encrypted so Pinggy cannot read it.
Keep software updated. Run sudo apt update && sudo apt upgrade regularly on the Pi.
Expose only what you need. Tunnel one service at a time and close the tunnel when done.
Watch the traffic. Pinggy's web debugger shows every request. The traffic inspection guide explains how to spot unexpected requests.

Troubleshooting

"Connection refused" on the tunnel: Make sure the local service is actually running and listening on the port you specified (ss -tlnp shows listening ports).
Tunnel will not start on Windows: Use 127.0.0.1 instead of localhost in the command.
Connection drops repeatedly: Add -o ServerAliveInterval=30 and run the tunnel under systemd so it restarts on failure.
Blocked on port 22: Pinggy connects over port 443, which most networks allow. Behind a strict proxy, the SSH reverse tunneling guide above shows how to route through an HTTP proxy.
Still unreachable: Check the tunnel type. A web app needs an HTTP tunnel, while SSH, databases, and most game servers need TCP (or UDP for games like Minecraft Bedrock).

Final thoughts

CGNAT is a limitation of your ISP's network, not a mistake in your setup, and no amount of router tweaking will fix it. Once you understand that, the fix is simple: stop waiting for the internet to reach you and connect outward instead. A reverse tunnel gives your Raspberry Pi or home server a public address without a static IP, a VPS, or router changes.

To try it, start a free tunnel from the Pinggy homepage and expose one local service to see how it works.

Reference

How to Access Your Home Server or Raspberry Pi When Your ISP Uses CGNAT

Bypass CGNAT: Reach Your Home Server or Raspberry Pi from Anywhere

Saptarshi Paul — Fri, 02 Oct 2026 14:25:52 +0000

Summary

What is CGNAT and why does it break home hosting?

In practice, CGNAT causes:

Self-hosted websites, dashboards, and home automation panels unreachable from outside
SSH to a Raspberry Pi only working on your local network
Game servers, media servers, and cameras inaccessible remotely
Webhooks failing to reach a home service

How to check whether you are behind CGNAT

Confirm it in about two minutes.

Find your router's WAN IP. Log in to your router admin page (often 192.168.1.1 or 192.168.0.1) and look for the WAN or Internet IP on the status page.
Find your public IP. Search "what is my IP" from any device on your network.
Compare. If they match, you have a public IP and ordinary port forwarding should work. If they differ, you are almost certainly behind CGNAT.

Why traditional port forwarding fails under CGNAT

Under CGNAT, you do not control that address. Your router cannot open a port on an IP it does not own, so the forwarding rule never sees traffic.

Your options for reaching a server behind CGNAT

Ask your ISP for a public IP. Some assign one, often for a monthly fee. Worth a support call, but not always available.
Use IPv6. If your ISP and the connecting device support it, IPv6 needs no NAT. Many home networks still lack end-to-end IPv6.
Rent a VPS and build a reverse tunnel. Full control, but you provision, secure, and maintain the server yourself.
Use an overlay networking tool like Tailscale. Great for private access between your devices, but not designed for giving the public a URL.
Use a managed tunneling service such as Pinggy. Your server connects outward to a public endpoint, and traffic flows back through that connection. Nothing to rent or maintain.

The last option works because CGNAT only blocks inbound connections. Outbound connections pass through, so a tunnel that starts inside your network goes straight out.

How reverse tunneling gets around CGNAT

Step-by-step: access your Raspberry Pi with Pinggy

Every modern Linux, macOS, and Windows system includes an OpenSSH client, so there is nothing to install. These steps use a Raspberry Pi, but they work for any Linux home server.

Step 1: Enable SSH on your Pi

On the Pi itself, with a keyboard and screen or over your local network, enable SSH:

sudo raspi-config

# Interface Options -> SSH -> Enable

sudo systemctl restart ssh

Step 2: Tunnel a web service (HTTP)

If your Pi runs a web app, dashboard, or API, run this on the Pi, replacing 8080 with the port your service uses:

ssh -p 443 -R0:localhost:8080 free.pinggy.io

Step 3: Reach the Pi over SSH (TCP tunnel)

To log in to the Pi remotely, create a TCP tunnel to its SSH port (22):

ssh -p 443 -R0:localhost:22 tcp@free.pinggy.io

Pinggy returns a hostname and port. From your laptop, connect with:

ssh -p <PORT> pi@<HOSTNAME>

Step 4 (optional): Use the Pinggy CLI

Keeping the tunnel alive

Auto-restart. Run the tunnel as a systemd service with Restart=always, so it reconnects after network drops or a reboot. Use ServerAliveInterval=30 in your SSH options to keep the connection healthy.
A stable address. Persistent URLs and custom domains are part of the Pro plan, so check current Pinggy plans if you need a permanent address.

A minimal service file looks like this. Use the exact command that works in your terminal:

[Unit]
Description=Pinggy tunnel to local SSH
After=network-online.target
Wants=network-online.target

[Service]
User=pi
ExecStart=/usr/bin/ssh -p 443 -R0:localhost:22 -o ServerAliveInterval=30 -o ExitOnForwardFailure=yes YOUR_TOKEN+tcp@free.pinggy.io
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Save it as /etc/systemd/system/pinggy-tunnel.service and start it with sudo systemctl enable --now pinggy-tunnel.

Security checklist for anything you expose

Making a device reachable from anywhere also makes it a target. Before you rely on a tunnel:

Use SSH keys, not passwords, and disable root login.
Add authentication to web services. Put basic auth or a login in front of dashboards and admin panels. Pinggy can add basic auth at the tunnel itself by appending -- b:user:pass to the command.
Use TLS tunnels when privacy matters. Pinggy's web debugger reads HTTP traffic to work. TLS tunnels keep traffic end-to-end encrypted so Pinggy cannot read it.
Keep software updated. Run sudo apt update && sudo apt upgrade regularly on the Pi.
Expose only what you need. Tunnel one service at a time and close the tunnel when done.
Watch the traffic. Pinggy's web debugger shows every request. The traffic inspection guide explains how to spot unexpected requests.

Troubleshooting

"Connection refused" on the tunnel: Make sure the local service is actually running and listening on the port you specified (ss -tlnp shows listening ports).
Tunnel will not start on Windows: Use 127.0.0.1 instead of localhost in the command.
Connection drops repeatedly: Add -o ServerAliveInterval=30 and run the tunnel under systemd so it restarts on failure.
Blocked on port 22: Pinggy connects over port 443, which most networks allow. Behind a strict proxy, the SSH reverse tunneling guide above shows how to route through an HTTP proxy.
Still unreachable: Check the tunnel type. A web app needs an HTTP tunnel, while SSH, databases, and most game servers need TCP (or UDP for games like Minecraft Bedrock).

Final thoughts

To try it, start a free tunnel from the Pinggy homepage and expose one local service to see how it works.

Reference

How to Access Your Home Server or Raspberry Pi When Your ISP Uses CGNAT

In-Browser LLM Inference with WebGPU: A 2026 Field Guide

Saptarshi Paul — Fri, 02 Oct 2026 13:57:50 +0000

Nearly every AI feature in a web app today is a round trip: the page collects text, sends it to a hosted model, and streams tokens back over the network. That design puts a per-token bill, a network hop, and someone else's data retention policy between your user and a text box.

Running the model inside the tab removes all three. In 2026 that is not a science project. WebGPU is available in every major browser engine, the current WebLLM release ships 163 prebuilt model builds, and a 4-bit Llama 3.2 1B is a 695MB download that needs roughly 880MB of GPU memory once running. Here is what actually works, the code that does it, and the specific places in-browser inference falls over.

Summary

There are three practical ways to run a language model inside a browser tab today:

WebLLM (@mlc-ai/web-llm 0.2.85, published 8 September 2026): WebGPU only, an OpenAI-shaped chat.completions.create() API, and 163 prebuilt model builds from SmolLM2 360M to Llama 2 13B.
Transformers.js (@huggingface/transformers 4.3.0, published 16 September 2026): WebGPU with a WebAssembly fallback, and far more than chat: embeddings, speech recognition, vision, classification.
Chrome's built-in Prompt API: the LanguageModel interface has been stable on the open web since Chrome 148 (5 May 2026). Nothing to download in your bundle, but it is Chrome-desktop only and Google requires 22GB of free disk and more than 4GB of VRAM.

WebGPU support, per MDN compatibility data: Chrome and Edge 113 on Windows, macOS and ChromeOS, with Linux added in 144 (Intel Gen12+ GPUs only); Chrome on Android 121; Safari 26 on macOS and iOS; Firefox 141 on Windows, with Apple silicon macOS arriving in 145 and 147 and Linux still unsupported; Samsung Internet 25.

Why the browser works as an inference runtime now

The unlock is WebGPU, not WebAssembly. WASM gave the browser fast CPU execution years ago, but matrix multiplication against a few billion parameters is a GPU job, and WebGL was built for drawing triangles rather than general compute. WebGPU exposes compute shaders and storage buffers directly, which is what makes a transformer's forward pass practical inside a tab.

The support picture is finally boring, which is the point. Chrome and Edge have shipped it since version 113 in May 2023, Chrome 144 added Linux for Intel Gen12 and newer GPUs, Safari 26 brought it to macOS and iOS in September 2025, and Firefox has had it on Windows since 141. The remaining holes are Firefox on Linux and on Intel Macs, and Firefox for Android.

Two caveats matter before you write any code. First, Firefox does not expose WebGPU inside service workers, so a service-worker-based engine will not run there. Second, WebGPU is secure-context only: navigator.gpu exists on HTTPS pages and on loopback origins such as localhost and 127.0.0.1, and is simply undefined everywhere else. That one rule causes most of the confusion later in this post.

WebNN, the API that would hand this work to an NPU instead, is still behind the #web-machine-learning-neural-network flag in Chrome and Edge and absent from Firefox and Safari, so nothing ships on it today.

The three ways to run a model in a tab

WebLLM is the most direct route to a chatbot. It is built on Apache TVM, compiles model-specific WebGPU kernels ahead of time, and exposes an OpenAI-compatible surface, so engine.chat.completions.create({ messages, stream: true }) behaves like the API you already call. Version 0.2.85 ships prebuiltAppConfig with 163 model entries, including Qwen3 and the newer Qwen3.5 family (0.8B through 9B), Llama 3.2 1B and 3B, Phi-4-mini, gemma3 1B, Ministral 3B and the DeepSeek-R1 distills. Usefully, it needs no cross-origin isolation: there is not a single reference to SharedArrayBuffer in the shipped bundle, because all the compute goes to WebGPU rather than to threaded WASM.

Transformers.js is the better choice when chat is not the whole job. Version 4 rewrote its WebGPU runtime in C++ and runs the same code in browsers, Node, Deno and Bun, and because it rides on ONNX Runtime Web it covers embeddings, ASR, image models and classifiers alongside text generation. You opt into the GPU per pipeline and pick a quantization with dtype, and when WebGPU is missing it falls back to WASM on the CPU instead of failing outright.

import { pipeline } from "@huggingface/transformers";

const generate = await pipeline("text-generation", "onnx-community/Qwen2.5-0.5B-Instruct", {
  device: "webgpu",
  dtype: "q4f16",
});

Chrome's built-in Prompt API inverts the tradeoff. The model (Gemini Nano) belongs to the browser, so your bundle stays small and there is no multi-hundred-megabyte first load, but you inherit Google's hardware gate: Windows 10/11, macOS 13+, Linux or ChromeOS, more than 4GB of VRAM, and at least 22GB of free disk on the profile volume, with the model evicted if free space later drops below 10GB. There is no Android or iOS support, and neither Firefox nor Safari implements it. Feature-detect with "LanguageModel" in self and call await LanguageModel.availability() first, since on a fresh profile the model still has to download. Chrome's docs decline to publish its size, pointing at chrome://on-device-internals instead.

Two more runtimes are worth knowing about. wllama (3.6.1, August 2026) wraps llama.cpp in WebAssembly and will run GGUF models on the CPU when there is no usable GPU, at the cost of needing Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy headers for multi-threading. And Google's MediaPipe LLM Inference API is now in maintenance-only mode, with the LiteRT-LM JavaScript API named as its successor, so new projects should not start there.

A working chat page

This is the whole thing. No build step, no bundler, one HTML file:

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <title>Local chat</title>
    <style>
      body { font: 15px/1.6 system-ui, sans-serif; margin: 2rem; max-width: 46rem; }
      textarea { width: 100%; font: inherit; padding: .5rem; }
      h2 { font-size: 13px; letter-spacing: .1em; text-transform: uppercase; color: #6b7280; }
      pre { white-space: pre-wrap; background: #f4f4f5; padding: .75rem; border-radius: .4rem; }
      #out { min-height: 4rem; background: #fff; border: 1px solid #e4e4e7; }
    </style>
  </head>
  <body>
    <h1>Local chat</h1>
    <textarea id="prompt" rows="3">Explain what a reverse proxy does, in two sentences.</textarea>
    <button id="send">Send</button>

    <h2>Engine status</h2>
    <pre id="status">loading the WebLLM runtime...</pre>
    <h2>Response</h2>
    <pre id="out"></pre>

    <script type="module">
      import { CreateMLCEngine } from "https://esm.run/@mlc-ai/web-llm@0.2.85";

      const status = document.getElementById("status");
      const out = document.getElementById("out");

      let engine;
      try {
        engine = await CreateMLCEngine("Llama-3.2-1B-Instruct-q4f32_1-MLC", {
          initProgressCallback: (report) => { status.textContent = report.text; },
        });
      } catch (err) {
        status.textContent = navigator.gpu
          ? `Could not start the engine: ${err.message}`
          : "This browser does not expose WebGPU. Check the support table above, and that the page is on https:// or localhost.";
        throw err;
      }

      document.getElementById("send").onclick = async () => {
        out.textContent = "";
        const started = performance.now();
        let tokens = 0;
        const stream = await engine.chat.completions.create({
          messages: [{ role: "user", content: document.getElementById("prompt").value }],
          stream: true,
        });
        for await (const chunk of stream) {
          const piece = chunk.choices[0]?.delta?.content ?? "";
          if (piece) tokens++;
          out.textContent += piece;
        }
        const secs = (performance.now() - started) / 1000;
        status.textContent = `${tokens} tokens in ${secs.toFixed(1)}s (${(tokens / secs).toFixed(1)} tok/s)`;
      };
    </script>
  </body>
</html>

Save it and serve it with python3 -m http.server 8000, then open http://localhost:8000. Do not open the file with a file:// URL: module imports and the secure-context rule both break there.

On the first run, initProgressCallback narrates a 695MB download split across 22 shards while WebGPU compiles the kernels:

That cold start ran three to five minutes across attempts here. On later visits the weights come out of the Cache API, which is WebLLM's default cache backend, so startup is dominated by shader compilation rather than network transfer: the same page reloaded in 1.4 seconds. For anything beyond a demo, move the engine into a worker with CreateWebWorkerMLCEngine so token generation stops blocking the main thread.

Once the status line reads "Finish loading on WebGPU", generation runs entirely on the local GPU:

That one produced 76 tokens in 1.1 seconds, or 66.8 tok/s, on an M3 Pro MacBook in Chrome 153. Repeat runs on the same laptop ranged from roughly 27 to 67 tok/s depending on GPU contention, so treat any single figure as a ballpark.

Picking a model that fits

Two numbers matter and they are not the same. The download is what your user waits for once; vram_required_MB is WebLLM's estimate of GPU memory for weights plus the KV cache at a 4096-token context, and it decides whether the tab runs at all. Both columns come from the model repositories and from prebuiltAppConfig in 0.2.85.

Model (q4f16_1 build)	Download	VRAM estimate
SmolLM2 360M Instruct	204 MB	376 MB
gemma3 1B Instruct	563 MB	711 MB
Llama 3.2 1B Instruct	695 MB	879 MB
Qwen3.5 2B	1,059 MB	2,245 MB
Qwen3 4B	2,263 MB	3,432 MB
Llama 3.1 8B Instruct	4,517 MB	5,001 MB
Qwen3.5 9B	5,038 MB	6,433 MB

The q4f16_1 suffix means 4-bit weights with fp16 activations, which needs the shader-f16 WebGPU feature; q4f32_1 is the fp32 fallback for adapters that lack it. Builds with a -1k suffix cut the context window to 1024 tokens, which is the cheapest way to shave several hundred megabytes off the VRAM estimate. If you want a sense of how far this can be pushed, Bonsai 27B runs a 1-bit 27B model in a browser tab at a 3.79GB download, and our guide to small LLMs that fit in 8GB covers the same size tradeoffs outside the browser.

Where it breaks

Memory is the first wall, and it is lower than the numbers above suggest. WebGPU's spec defaults guarantee only a 256MB maxBufferSize and a 128MB maxStorageBufferBindingSize; anything larger has to be requested explicitly at requestDevice() and granted by the adapter. WebLLM asks for 1GB on both, logs a warning and retries at 256MB and 128MB if the adapter refuses, and throws Cannot initialize runtime because of requested maxBufferSize exceeds limit when even that fails. Adapters vary widely here: Chrome 153 on an M3 Pro Mac reports a 4,294,967,292 byte ceiling for both limits, while a low-end integrated GPU may sit at the spec minimum. When a model does not fit at runtime you usually see the device lost instead of a clean error, which is why WebLLM ships the string WebGPU device was lost while loading the model with a note that it is usually an out-of-memory condition.

The CPU path has its own ceiling. WebAssembly is still 32-bit in practice, capping linear memory at 4GB, and wllama additionally hits a 2GB per-file ArrayBuffer limit that it works around by splitting GGUF files into roughly 512MB chunks. Memory64 has been enabled by default in Chrome since milestone 133, but it is not something you can assume across browsers yet.

Then there is the awkward stuff no API fixes. A multi-gigabyte first download is a real conversion cost, phones throttle under sustained decoding, and a 1B model is not a frontier model, so this suits classification, extraction, rewriting and offline drafting far better than long agentic reasoning.

Testing it on a real phone

This is where the secure-context rule bites. Your laptop opens http://localhost:8000 fine, because loopback origins are trusted. Point your phone at http://192.168.1.50:8000 on the same Wi-Fi and navigator.gpu is undefined, so the page fails before it downloads a single shard. Chrome on Android has supported WebGPU since 121, but it will not hand it to a plain-HTTP origin.

The quickest fix is an HTTPS tunnel to the static server you already have running with python3 -m http.server 8000. In a second terminal:

ssh -p 443 -R0:localhost:8000 free.pinggy.io

Pinggy prints a public https:// URL that forwards to port 8000, which gives the phone a genuine secure context with no certificate wrangling, no router configuration, and nothing to install. Open that URL on the device, and the same WebGPU code path that worked on your desktop runs on the phone's GPU. The HTTP tunnel docs cover the options worth adding for a longer session, such as keepalive and basic auth.

So when is this the right call?

In-browser inference wins when privacy is the feature rather than a footnote, when a demo has to keep working on a plane, or when per-token cost matters more than absolute quality: classification, redaction before an upload, autocomplete, or summarizing something the user would rather not send anywhere. It is the wrong tool when you need frontier quality, a long context, or predictable performance on unknown hardware, because your users' GPUs are not your GPUs.

Conclusion

The honest summary for 2026 is that the platform is ready and the models are the limiting factor. WebGPU is in every engine, the runtimes are maintained and moving quickly, and a 1B model in a tab is a 695MB download away.

The shortest useful path is the page above: WebLLM with Llama-3.2-1B-Instruct-q4f32_1-MLC, served on localhost, with the engine moved into a worker before you show it to anyone. Reach for Transformers.js when the job is embeddings, speech or vision rather than chat, and for Chrome's Prompt API only if Chrome-desktop-only is acceptable. Then check it on a phone over an HTTPS tunnel and size the model for the weakest GPU you care about, because that machine decides whether the feature ships.

Reference

Run an LLM Inside a Browser Tab: WebGPU and Local Inference in 2026

How ZuckOff Uses BLE Fingerprints to Detect Camera Glasses Nearby

Saptarshi Paul — Fri, 02 Oct 2026 13:35:12 +0000

Camera glasses don't wait for permission to announce themselves. Every time a pair of Ray-Ban Meta, Oakley Meta, or Snap Spectacles is in Bluetooth range, it sends out a BLE advertisement packet with a manufacturer ID, a short number baked into the chip. If you know which IDs belong to which glasses, you can build an app that listens for those packets and tells you when camera-capable hardware is nearby. That is exactly what ZuckOff does. It is a free iOS and Android app by Pawel Szydlowski, a Polish developer who bought several pairs of camera glasses, captured their Bluetooth traffic, and built a matching catalog. The app has picked up around 5,000 users since landing in the App Store last month.

Szydlowski's reasoning is direct: "We as a society have the right to at least know that someone is recording." He doesn't claim the app can prove recording is happening. It can't. It turns an invisible nearby camera into something you can at least be aware of.

How detection actually works

BLE devices don't wait to be queried. Most continuously broadcast small advertisement packets, a few dozen bytes that announce their existence, approximate distance via signal strength, and often a manufacturer-specific data field identifying the chipset or company. ZuckOff reads that field. This is not a hack or exploit; the packets are public by design, like a Wi-Fi router broadcasting its SSID.

Szydlowski's catalog maps manufacturer data to real products:

0x0D53 -> Luxottica: Ray-Ban Meta, Oakley Meta
0x058E -> Meta Platforms Technologies wearable
0x03C2 -> Snap: Spectacles
0xFD5F -> service UUID registered to Oculus VR

The app also flags plaintext product names like "Spectacles", "HeyCyan", or "VisionPro" at lower confidence, since name strings are easier to spoof or accidentally match than registered manufacturer IDs. Every rule, per the app's description, "comes from a capture of a real device." Szydlowski owns a few pairs and is asking owners of unlisted hardware to send him a short Bluetooth capture or loan him the glasses so the catalog can grow. It is a crowdsourced fingerprint database bootstrapped by one person buying hardware out of pocket.

The rest of the app is straightforward once detection exists. It shows the evidence behind every flag instead of a bare "camera nearby" warning, logs every Bluetooth device it hears whether or not it matches, lets you mark glasses you own so they stop raising alerts, and exports the whole log as CSV. On iPhone there is a Lock Screen Live Activity and Home Screen widget. On both platforms you can start and stop scans from Siri, Shortcuts, or an automation. No account is required, and the app's privacy claim is that nothing leaves the phone.

What it can't tell you

The app is upfront about its limits. Glasses broadcast loudest when powering on, pairing, or coming out of the case. Most pairs keep advertising continuously while worn, but the documentation notes that "a few standalone models stay silent." Quiet doesn't mean nobody is recording, and a detection doesn't mean anyone is either. It means camera-capable hardware is somewhere in Bluetooth range. Signal strength gives a rough distance, not a direction, so ZuckOff can tell you a pair is close without telling you where to look.

Third-party testing confirms the same picture: the app identifies hardware capable of recording, not an active recording session, and it can't identify who is wearing the glasses.

The LED that keeps getting patched around

Meta's own answer to this problem is a small white LED that lights up while the camera is recording. It has been trivial to defeat almost since launch. Engadget tested a $16.99 kit of a dozen stickers sold on Amazon and TikTok Shop: a notched clear layer over the sensor and a black sticker over the light itself, cheap enough per sticker that the headline rounded it down to "a $2 sticker." Worn outdoors on second-generation Ray-Ban Meta glasses, the LED became undetectable and never tripped Meta's tamper warning. Hobbyists have also physically removed the LED for around $60, leaving the glasses looking stock.

Meta has been chasing the loophole in software. An earlier fix targeted the moment recording starts: if the LED was already covered, the camera would refuse to record. The gap was starting a recording first and covering the light after. An update rolling out on August 28, 2026 closes that too. Per Meta's VP of AR, "the camera will now stop working if the light is covered during a recording." It's an incremental fix to a signal that keeps getting worked around. A detector that reads a hardware manufacturer ID rather than a light is a different kind of check. You can't sticker over a Bluetooth radio without breaking the reason the glasses have one.

Why this is landing now

Meta is not standing still. On September 15, 2026, the company launched Meta One, a bundle of paid tiers across Instagram, Facebook, WhatsApp, and Meta AI starting at $2.99 a month and running up to $499 for business accounts. Two days from now, at Connect on September 23, Meta is expected to unveil Luna: glasses with no camera, replaced by six onboard microphones, a temple button for the AI assistant, and slimmer arms, shipping this fall in two versions codenamed Clubmaster and Burbank. TechCrunch's framing is pointed: Meta is building a pair "without integrated spy equipment," months after the current camera-equipped line drew accusations of enabling covert filming.

The money underneath is not subtle. Reality Labs lost about $4 billion in Q1 2026 and another $4.6 billion in Q2, pushing cumulative losses since the division's creation to roughly $88 billion. Camera-equipped glasses have been one bright spot in sales, and also the source of a growing privacy backlash: venues from cinemas to schools to pubs in the UK have started banning them outright. Meta building a camera-free variant and layering subscription revenue in the same month reads less like coincidence and more like hedging against the exact criticism an app like ZuckOff exists to make visible.

A small coincidence in the name

The app's name is a jab at Mark Zuckerberg, but it also happens to be the surname of an unrelated real person: Mitchell Zuckoff, a journalism professor who found out about the app through news coverage. He decided not to pursue it, saying he had more pressing things to focus on, including work related to child surveillance protection. A footnote, but a good one.

Detection as a category, not a one-off

ZuckOff isn't the only tool doing this. Similar Bluetooth-based detectors exist for Android, and the pattern is bigger than any single app. As camera-equipped wearables ship by the million with no built-in way for bystanders to opt out, independent developers are quietly building the accountability layer the manufacturers didn't. None of it needs venture funding. The stack is a phone's Bluetooth radio, a catalog of manufacturer IDs built by buying hardware and capturing packets, and a UI that shows its work. The free tier does the actual detection; a $9.99-a-year or $24.99-lifetime Pro tier funds background alerts and, per the developer, the next pair of glasses worth capturing. That's a strange but honest business model: the privacy tool doesn't monetize your data, because there isn't any to sell. It monetizes convenience, and it grows exactly as fast as one person can afford new hardware to reverse-engineer.

Reference

ZuckOff: The Bluetooth Fingerprint That Gives Away Meta's Camera Glasses

The 2026 B2B SEO Agency List: 18 Firms That Focus on Pipeline, Not Just Rankings

Saptarshi Paul — Fri, 02 Oct 2026 13:11:57 +0000

Pricing for B2B SEO retainers ranges from $2,500 to more than $50,000 a month, and the difference is not always quality. The harder problem is finding an agency that understands long sales cycles, technical buyers, and multi-touch decision-making. Most agencies optimize for quick wins and vanity traffic, and that approach falls apart when your buyer takes months to convert and pulls in five stakeholders along the way.

This list covers 18 B2B SEO agencies that work on complex, considered markets. Each has a different strength: demand generation, content-led SEO, or technical audits at scale. Use the summary below to narrow down which one fits your business, then read the full profiles for pricing, team structure, and engagement models.

Summary

Full-stack growth: NEWMEDIA.COM, Directive Consulting, Powered by Search, Kalungi, and Foundgrove bundle search with web development, paid media, conversion optimization (CRO), or go-to-market work.
B2B and SaaS search specialists: B2BSEO.io, Skale, SimpleTiger, MADX Digital, Growfusely, and Breaking B2B run technical SEO, content, links, and AI search as one program.
Content-led: Grow and Convert, Omniscient Digital, Animalz, Foundation Marketing, and Loudspeaker Marketing start from content strategy and editorial.
Technical SEO for large or messy sites: Onely and iPullRank.
Pricing varies a lot. Published monthly rates run from $2,500 (Foundgrove) to more than $50,000 (Kalungi), and several agencies only quote custom pricing.
Judge on pipeline, not traffic. Ask for a case study that ties one page to leads, ask who will actually work on your account, and be wary of guaranteed rankings or long contracts before you have seen a deliverable.

The List

1. NEWMEDIA.COM

NEWMEDIA.COM approaches B2B SEO as part of a broader growth program. Work spans technical SEO, content, link building, AI search, and website development, with strategy shaped around a company's sales goals.

Best fit: B2B companies that want SEO alongside web development, paid media, PR, or conversion optimization. The range may help companies with complex websites or multiple growth priorities.
B2B experience: Dedicated B2B SEO services for SaaS, enterprise services, and other business solutions. Published case studies include a B2B ecommerce company, so ask for examples from your own industry and business model.
SEO team: A multidisciplinary team across SEO, content, web design and development, paid media, and CRO. Ask who leads SEO strategy and which specialists handle day-to-day work.
Engagement model: Custom programs. Confirm which services are included in your proposal and how progress is reported.
Typical investment: Custom proposals.

2. B2BSEO.io

B2BSEO.io is a specialist B2B SEO agency for companies that want search to reach buyers while they are researching, comparing vendors, and building a shortlist. The work covers Google and AI search, with a focus on commercial pages, SaaS content, and authority building.

Best fit: B2B SaaS and service companies with a defined market, a considered sales process, and a need to connect organic visibility with qualified leads or pipeline.
B2B experience: Published case studies across B2B SaaS, healthcare, industrial, and professional services. SaaS examples include FeedBird and TrackDesk, and one case study describes growing a client's blog traffic from over 80,000 to more than 250,000 monthly organic visits over a year.
SEO team: Led by founder Ashot Nanayan. Covers technical SEO, content, on-page optimization, link building, and AI search visibility. Ask who owns each part of the work and how much direct access you will have to the people doing it.
Engagement model: Ongoing SEO programs plus focused services such as audits and link building. Tracks outcomes beyond rankings and visits.
Typical investment: Custom pricing.

3. Grow and Convert

Grow and Convert takes a narrower approach than most content agencies. Founders Benji Hyam and Devesh Khanal built the agency around Pain Point SEO, which prioritizes keywords tied to real customer problems and buying intent.

The team also tracks conversions at the article level. That lets B2B companies see which pages produce demos, trials, and leads, instead of judging content on traffic alone.

Best fit: B2B SaaS and service companies with clear product-market fit, well-defined customer pain points, and access to internal experts.
B2B experience: Reports generating more than 600 trials and demos a month for Smartlook. Work for Leadfeeder produced more than 215 sign-ups and 21,000 organic visitors a month.
SEO team: Around 20 strategists and writers across the United States and Europe. Clients work directly with content strategists rather than going through a separate account manager.
Engagement model: Fully managed content programs covering research, SEO and GEO (generative engine optimization, the work of getting cited in AI answers) strategy, writing, link acquisition, and conversion reporting.
Typical investment: From $10,000 a month. No long-term contract is required.

4. Skale

Skale was built by SaaS growth operators rather than generalist agency marketers. Co-founder Jake Stainer previously grew Typeform's SEO channel from zero to more than 30,000 monthly sign-ups. Co-founder Italo Viale brought experience from more than 120 SEO accounts.

Best fit: Funded and growth-stage B2B SaaS companies that want technical SEO, content, link building, and AI search run through one program.
B2B experience: More than 100 SaaS and technology companies, including Attest, Aircall, Perkbox, Slite, and Maze. Skale reports increasing Attest's product sign-ups 8.5 times.
SEO team: A global team of nearly 40 specialists across technical SEO, content, digital PR, link building, conversion optimization, and GEO.
Engagement model: Full-service retainers, plus separate engagements for content, links, technical SEO, or website migrations.
Typical investment: SEO services from £4,000 a month.

5. Omniscient Digital

Omniscient Digital brings a lot of in-house B2B software experience to agency work. Co-founders Alex Birkett, Allie Konchar, and David Ly Khim previously held growth or content roles at HubSpot, Shopify, Workato, and People.ai.

The team treats SEO as an organic growth channel tied to pipeline. It also covers AI search, content strategy, technical SEO, digital PR, and conversion optimization.

Best fit: Established B2B software companies with internal marketing support and enough subject-matter expertise to produce differentiated content.
B2B experience: Clients include SAP, Jasper, Order.co, Asana, Loom, and Hotjar. Reports generating $4 million in blog-attributed annual recurring revenue (ARR) for Jasper and $400,000 in qualified pipeline for Teambridge.
SEO team: Senior strategists work alongside technical SEO specialists, editors, writers, conversion experts, and digital PR people.
Engagement model: Full-service monthly programs, or standalone SEO and content strategy projects.
Typical investment: Full-service engagements start at $10,000 a month. Strategy projects start at $15,000.

6. Directive Consulting

Directive Consulting puts SEO inside a wider B2B customer-generation program. The team combines technical SEO, content, paid media, conversion optimization, and analytics. That model suits companies that want search data tied to opportunities and revenue across the full funnel.

Best fit: Mid-market and enterprise B2B SaaS, cybersecurity, fintech, and technology companies with mature demand-generation teams.
B2B experience: Reports increasing Inscribe's keyword rankings by 237% and organic traffic by 32%. Its AxisCare campaign produced 200% more demos and brought in new sales-qualified leads through AI search.
SEO team: SEO strategists are backed by content, analytics, paid media, design, and conversion specialists.
Engagement model: Custom retainers that can combine SEO with paid acquisition, CRO, content, and performance analytics.
Typical investment: Custom pricing.

7. SimpleTiger

SimpleTiger works only on SaaS SEO. The agency has spent more than 15 years with software companies and now combines traditional search with GEO, AEO (answer engine optimization), content, link building, paid media, and Webflow support.

That narrow focus means the team knows product-led funnels, integration pages, and comparison content, and can tell informational traffic apart from qualified software buyers.

Best fit: Growth-stage B2B SaaS and AI companies that want one specialized team for SEO, content, authority building, and AI visibility.
B2B experience: Reports increasing Centerbase's top-three rankings by 193%. Work for Segment grew traffic to integration pages by 127% within two months, and one primary integration page grew by 597%.
SEO team: A boutique team covering technical SEO, content strategy, writing, link building, paid media, Webflow, and account management.
Engagement model: Customized SEO and GEO packages with shared reporting, Slack access, and a dedicated account manager.
Typical investment: Custom pricing based on growth stage and scope.

8. MADX Digital

MADX Digital specializes in search for SaaS and technology companies. The team covers SEO, content, digital PR, backlinks, development, analytics, and project management.

The agency folds GEO into its Google SEO work instead of selling AI visibility as a separate add-on. Technical work includes crawlability, indexation, internal linking, site architecture, and performance.

Best fit: Funded B2B SaaS, fintech, AI, and enterprise software companies that need technical SEO and authority building under one program.
B2B experience: Reports working with more than 50 SaaS brands. Its Thunes campaign took top-three rankings from 32 to 372 and raised estimated organic traffic value by 520%.
SEO team: SEO managers, technical specialists, content managers, link builders, analysts, developers, and quality-assurance editors.
Engagement model: Managed SEO programs, or separate projects for strategy, content, links, and digital PR.
Typical investment: Plans start at $3,500 a month. Growth plans start at $5,500 and scale plans at $9,500.

9. Powered by Search

Powered by Search has worked with B2B SaaS and technology companies since 2009. Its approach combines SEO, GEO, content, digital PR, conversion optimization, and revenue operations.

The agency puts unusual weight on positioning and pipeline attribution. That makes it more relevant for companies whose search problem goes beyond rankings, into weak messaging or poor lead tracking.

Best fit: Established B2B SaaS, cybersecurity, fintech, and healthtech companies with product-market fit and lean internal marketing teams.
B2B experience: Reports working with more than 200 B2B companies. That experience covers software categories with long sales cycles and several decision-makers.
SEO team: A distributed team across more than eight countries. Depending on the plan, clients work with one SEO strategist or an embedded group covering SEO, content, digital PR, CRO, and revenue operations.
Engagement model: Consulting, implementation, and full promotion programs.
Typical investment: Monthly plans start at $9,000. Quarterly billing starts at $7,500 a month.

10. Animalz

Animalz made its name writing editorial content for B2B SaaS companies. The agency started in New York in 2015 and now runs as a remote global team, with specialists in content strategy, editorial, AI search, and marketing operations.

Clients include well-known technology brands such as Amazon, Airtable, Atlassian, Auth0, Intercom, Ramp, and UiPath.

Best fit: Established B2B SaaS companies that need strong editorial content, executive thought leadership, SEO, and AEO.
B2B experience: Reports generating 25,000 additional monthly visitors for Preply and millions of dollars in pipeline for Unit21. Its SupportLogic program increased organic traffic fivefold.
SEO team: Content strategists, editors, writers, AI search specialists, and marketing operations staff.
Engagement model: Ongoing content and organic growth programs covering strategy, production, refreshes, content engineering, and AI citation tracking.
Typical investment: Custom pricing.

11. Foundation Marketing

Foundation Marketing pairs B2B content strategy with distribution. The team covers SEO, AEO, technical audits, digital PR, Reddit, YouTube, content repurposing, and analytics. That breadth is useful when publishing more content has stopped producing growth.

Best fit: Established B2B SaaS companies with valuable content libraries that need stronger SEO, refreshes, distribution, and authority.
B2B experience: Client work includes brands such as Canva and Procore. Foundation Marketing also reports growing traffic for an event software company by 156% after refreshing more than 100 posts and producing 50 to 70 new assets.
SEO team: A global team of strategists, technical SEO specialists, writers, distribution experts, analysts, and digital PR people.
Engagement model: Strategy projects, audits, and ongoing implementation programs.
Typical investment: Custom pricing.

12. Kalungi

Kalungi is a full-service B2B SaaS marketing agency, not an SEO-only shop. Co-founder Stijn Hendrikse developed the T2D3 framework around the growth stages SaaS companies move through after finding product-market fit.

SEO sits inside a broader go-to-market system that includes positioning, content, paid acquisition, ABM, design, CRM, and marketing operations.

Best fit: Post-product-market-fit B2B SaaS companies between roughly $5 million and $50 million in annual recurring revenue.
B2B experience: Reports working with more than 70 B2B SaaS companies. Its campaign for CCD Health increased marketing-qualified leads by 750% and US website traffic by 869%.
SEO team: Clients can get an associate CMO plus a wider execution team covering SEO, content, paid media, design, ABM, CRM, and marketing operations.
Engagement model: Done-for-you marketing, collaborative consulting, and self-directed T2D3 programs.
Typical investment: Full-service engagements start at more than $50,000 a month.

13. Growfusely

Growfusely works only with B2B SaaS and AI-native companies. Founder Pratik Dholakiya leads search strategy, while specialists handle technical SEO, content, digital PR, authority building, and AI citations.

The work goes past publishing articles. The team looks at site architecture, entity clarity, structured data, LLM crawler access, and the third-party sources that shape AI recommendations.

Best fit: B2B SaaS companies in cybersecurity, fintech, developer tools, compliance, and AI. Makes particular sense for teams that want SEO and AI search managed in the same program.
B2B experience: More than 55 SaaS and AI-native brands such as Wix, Whatfix, FreshBooks, Sprinto, JetOctopus, and Document360. Reports 217% qualified traffic growth for Mind the Graph, and work for JetOctopus doubled organic traffic within six months.
SEO team: Direct access to senior leadership and specialists across technical SEO, content, authority building, digital PR, and AI citation tracking. The same team stays involved after onboarding.
Engagement model: One-off audits, 90-day sprints, ongoing retainers, and advisory engagements.
Typical investment: Audits start at $2,000. Retainers start at $3,000 a month, and sprints at $4,000 a month.

14. Loudspeaker Marketing

Loudspeaker Marketing builds organic growth programs for B2B SaaS startups and scaleups. The team combines content strategy with programmatic SEO, conversion tracking, GEO, AEO, and custom AI workflows. AI is used to speed up research and intent analysis, but experienced operators still run the program.

Best fit: Fast-moving B2B SaaS and AI companies that need content clusters, programmatic SEO, and AI search visibility without building a large internal team.
B2B experience: Reports working with more than 70 companies. Client references include 11x, Rivo, Archive, Landbase, Ark7, and Reddit's small-business growth team. Landbase reported 42% more organic visitors and 66% more large language model (LLM) sessions after the agency published 79 articles in two months.
SEO team: Accounts are run by growth operators and strategists who have worked inside startup marketing teams. The agency presents itself as an extension of the client's team rather than a separate content vendor.
Engagement model: Flexible organic growth programs covering strategy, content production, technical improvements, programmatic SEO, and conversion tracking.
Typical investment: Custom pricing.

15. Breaking B2B

Breaking B2B is a specialist SEO and AI search agency for B2B companies. It is built around one simple position: search should generate pipeline, not vanity traffic.

The team starts with commercial pages and bottom-of-funnel opportunities before moving on to broader informational topics. Technical SEO, authority building, conversion improvements, GEO, and AEO all sit inside the same program.

Best fit: B2B SaaS and service companies in fintech, healthtech, martech, logistics, financial services, and construction.
B2B experience: More than 50 B2B companies have worked with Breaking B2B. Reports helping VerifyTreatment grow from five to 32 demos a month. RB2B increased non-branded organic traffic by 77%, and Chattermill raised its AI search mention rate from 20% to 80%.
SEO team: A senior strategist owns each account, backed by experienced SEOs and B2B specialists. Breaking B2B says it does not hand accounts to junior managers.
Engagement model: Six-month or 12-month programs covering technical SEO, commercial content, link building, AI search, and pipeline reporting.
Typical investment: Tailored plans start at $4,000 a month. Standard growth programs start at $5,500 a month.

16. Onely

Onely is one of the more technical agencies on this list. The team takes on problems that typical content agencies cannot solve: rendering failures, wasted crawl budget, server-log analysis, headless architecture, structured data, international SEO, and whether AI search can extract your content at all.

Best fit: Enterprise B2B and SaaS companies with large websites, JavaScript frameworks, international domains, headless platforms, or serious crawl and indexation problems.
B2B experience: Worked with G2, 123FormBuilder, Europejski Fundusz Leasingowy, and other companies with technically complex websites. Its Stratos Jets project produced a reported 195% increase in organic traffic and a 1,931% increase in search visibility.
SEO team: Technical SEO specialists who can work with server logs, JavaScript, structured data, site architecture, and your development team.
Engagement model: Technical audits, strategy projects, implementation support, traffic-drop recovery, and ongoing consulting.
Typical investment: Custom hourly pricing based on project complexity.

17. iPullRank

iPullRank works at the technical end of enterprise search. Its framework brings technical SEO, information retrieval, content strategy, digital PR, audience research, and AI search into one system.

The team can handle large websites where rendering, internal linking, structured data, site migrations, and content quality cause problems at scale.

Best fit: Enterprise B2B companies with complex websites, several business units, large content libraries, or advanced AI search requirements.
B2B experience: Founder Mike King has advised brands such as SAP, American Express, and HSBC. iPullRank reports generating more than $5 billion in organic search results across its client work. One ecommerce project produced $290 million in revenue and 5.4 million additional organic sessions year over year.
SEO team: Technical SEOs, content strategists, data specialists, engineers, digital PR people, and AI search researchers.
Engagement model: Custom enterprise programs covering technical SEO, content engineering, GEO, audience research, and Relevance Engineering.
Typical investment: Custom pricing. AI Search Strategy programs start at $15,000 a month.

18. Foundgrove

Foundgrove is a US-based agency whose core market is service businesses, though it also promotes B2B SEO for SaaS companies and manufacturers. It combines technical SEO, local search, content, link building, GEO, AEO, paid media, and conversion-focused web development.

Its model is built around booked calls and CRM revenue rather than rankings alone.

Best fit: B2B service companies, manufacturers, multi-location businesses, and smaller SaaS companies that need search, paid media, and website improvements from one partner.
B2B experience: Publishes a dedicated B2B program for SaaS companies and manufacturers. One anonymized project involved a dental technology manufacturer selling technical products to clinicians. Its public B2B case-study library is still smaller than those of the more established agencies on this list.
SEO team: Every account gets a US-based senior strategist. Foundgrove says it does not use offshore teams or white-label resellers.
Engagement model: Month-to-month programs combining SEO, GEO, AEO, paid advertising, and conversion-focused web development.
Typical investment: From $2,500 a month, with no long-term contract.

How we picked these B2B SEO agencies

We started with a list of more than 40 agencies that claim B2B SEO experience, then narrowed it down. First, we looked for published case studies that tie SEO work to pipeline or revenue, not just traffic charts. Agencies that only showed ranking screenshots got cut early.

We also weighed how long each agency has worked in B2B specifically. Sales cycles, buyer research habits, and content needs differ a lot from B2C or ecommerce work. Agencies that spread their focus across too many verticals without a clear B2B specialty did not make the final cut.

Client reviews on Clutch and G2 counted too, along with how open each agency is about pricing and process on its own site. The 18 agencies above made it through all three filters.

What a strong B2B SEO partner should do

A strong B2B SEO partner starts with your buyer, not your keyword list. That means researching who makes the purchase decision, what they search for at each stage, and which objections come up before a deal closes.

From there, a good partner builds content around your sales cycle instead of generic top-of-funnel topics. They should also handle the technical side, including site structure, page speed, and indexing, so the content has a real chance to rank once published.

Reporting matters too. A strong partner shows which pages drive traffic that turns into leads, not just which pages get the most visits. And they should be honest about timelines. B2B SEO takes months to show results, and any partner promising overnight wins is setting you up for disappointment.

How to choose an agency that understands your sales cycle

Start by asking how the agency researches your buyers before writing a single piece of content. Do they talk to your sales team, review past deals, and look at what your best customers searched for before they became customers? If the answer is vague, they probably treat every client the same way.

Ask for examples of content the agency wrote for a company with a similarly long or complex sales cycle. A blog post that works for a $50-a-month subscription tool reads very differently from one written for a $50,000 annual contract that needs sign-off from procurement, legal, and finance.

It is also worth checking whether the agency understands the difference between top-of-funnel awareness content and bottom-of-funnel content built to move a deal forward. Agencies that only produce one kind usually do not grasp how B2B buying works.

Questions to ask before you sign an SEO retainer

Before signing anything, ask the agency how they define success. If they only talk about rankings and traffic, keep pushing until they connect the work to pipeline and revenue.

A few other questions worth asking directly:

Who will work on our account, and will we have access to senior strategists or mostly junior staff?
What do the first 90 days look like, and what should we expect to see by month three?
How do you handle content that touches technical or regulated topics?
What happens if our internal team cannot turn around approvals or dev requests quickly?
Can we see reporting examples from a client in our industry?

A vague answer to any of these is worth a second look before you commit budget.

What B2B SEO costs, and what changes the price

Most B2B SEO retainers run between $3,000 and $20,000 a month, with enterprise engagements going higher. A few factors push the price up or down.

Scope is the biggest driver. An agency handling technical SEO, content production, and link building charges more than one focused only on content. Industry complexity matters too. Fintech, healthcare, and legal content often needs subject-matter review, which adds cost.

Team structure also plays a role. Agencies that put senior strategists on every account tend to charge more than those relying on junior writers with light oversight. And keyword difficulty in your market affects how much work it takes to rank at all, which shows up in the quote.

When to hire a B2B SEO agency instead of building in-house

Hiring in-house makes sense once you have a steady budget for a full team: a strategist, a writer or two, and someone handling technical SEO. Below that threshold, you are usually paying more for less coverage than an agency gives you.

An agency also makes sense when you need specialized skills fast, like digital PR relationships or a technical audit for a complex site migration. Building that expertise in-house takes months, sometimes years.

In-house teams tend to win when your product is niche enough that outside writers struggle to produce credible content without heavy internal review on every piece. If your team is already correcting most of what an agency sends over, that is a signal to bring the work in-house.

How to tell whether an agency can drive qualified leads

Traffic and rankings are the easy part to show. Qualified leads are harder, and that is where most agencies get vague. Ask for a case study that shows the full path: keyword targeted, content published, ranking achieved, and the leads or pipeline that came from that specific page.

Agencies that cannot produce this usually do not track anything past traffic, which means they do not know whether their work drives revenue. Also ask how they define qualified. A demo request from a student researching a class project is not the same as one from a director at a company that fits your ideal customer profile.

If an agency can walk you through its targeting logic, keyword by keyword, and tie it back to your sales team's definition of a good lead, that is a strong sign it understands B2B growth beyond surface metrics.

Red flags to watch for in an agency pitch

A few warning signs to look for before you sign:

Promises of guaranteed rankings, or a specific position on Google within a fixed timeframe
Case studies that show traffic growth but never mention leads, pipeline, or revenue
Heavy reliance on AI-generated content with little or no editorial review
Vague answers about who will work on your account
Pressure to sign a long-term contract before you have seen a single deliverable
No clear process for researching your buyers and sales cycle before writing content

None of these alone is disqualifying, but two or three together usually mean the agency is optimizing for closing your deal, not for running your campaign.

How to compare agencies beyond their case studies

Case studies are curated by design, so they only tell part of the story. Ask each agency for a reference client of a similar industry or company size, and actually call them. Ask that reference what the agency is bad at, not just what it is good at.

Look at how each agency talks about failure. Every agency has clients who did not see results, and the ones worth hiring can explain why, honestly, without blaming the client.

It also helps to compare how each agency thinks, not just what it has done. Ask them to walk through how they would approach your specific market on the first call. The quality of that thinking often tells you more than any past client logo.

Reference

18 B2B SEO Agencies Worth a Closer Look in 2026

Open Source Jev Alternatives: Five Self-Hosted Decision Models to Run Yourself

Saptarshi Paul — Fri, 02 Oct 2026 12:50:25 +0000

Most of the decisions software asks a model to make are small and repetitive: route this ticket, flag this message, rate this severity. Those calls never needed prose. Paying a frontier model to generate a sentence you immediately parse back into an if statement has always been the wrong shape for the job.

TypeSafe shipped Jev on September 15, 2026 to do exactly that job and nothing else, then kept it closed, hosted, and behind a waitlist. The first open reimplementations appeared within about 24 hours. AINews counted six clones in two days on September 19, and the awesome-jev list now tracks more than a dozen. The largest has 19,301 GitHub stars, and it added over 5,000 of them in the last day alone.

Below are the five worth your time, ranked by GitHub stars pulled from the API on September 23, 2026. Two of them I ran on an Apple M3 Pro while writing this.

Summary

The open field reproduces Jev's interface well, and only partly reproduces its accuracy.

Laya (19,301 stars, Apache-2.0): 421M on ModernBERT-large, pip install laya, 32.8-39.5 ms per question on a T4. Its base checkpoints score near chance zero-shot, so it is a base to fine-tune, not a drop-in.
Kev (5,385 stars, Apache-2.0): LoRA adapters on Qwen3.5 at 0.8B, 4B and 9B, serving TypeSafe's /v1/systemone contract so the official SDK works unchanged. Its new MLX backend answered in 47 ms on my Mac.
SemIf (4,023 stars, MIT) trains no model: it reads option logits off a frozen Qwen3.5-4B, measuring 1.023 s against 5.332 s for the same 21 decisions via generated JSON.
NanoJev (2,086 stars, MIT) is a 0.6B model for real-time control loops, beating Jev 128/128 to 56/128 on ViZDoom Basic. Not a general classifier.
jevlike (1,255 stars, MIT) ships a trainer, not a model: bring labelled options and train an option-attention head on a laptop.
Caveat: on the independent 49-task classifier benchmark, Jev scores 0.966 macro accuracy against 0.704 for the best open entrant. These projects win on latency, price and control, not out-of-the-box accuracy.

Why a dozen clones appeared in a week

A System One model is narrow, and that is what made it easy to copy. You hand it a block of state plus questions with declared answer types: a Choice over up to 255 options, a Score on an ordered scale, a Noul yes/no probability. It fills every answer in one parallel pass instead of decoding tokens. Nothing to parse, nothing to repair.

That interface is public in TypeSafe's API docs; the model and training data are not. Reproducing the contract takes a weekend, because reading option logits off any open-weight model gives the same shape of answer. Reproducing the quality is a research problem, and a week is not long enough.

Comparison table

Project	Stars	License	What it runs	Best for
Laya	19,301	Apache-2.0	ModernBERT-large 421M, mmBERT-base 322M	CPU-friendly triage, 100+ languages
Kev	5,385	Apache-2.0	Qwen3.5 0.8B / 4B / 9B + LoRA	Swapping out a hosted Jev call
SemIf	4,023	MIT	Frozen Qwen3.5-4B (no fine-tune)	Reusing a model you already host
NanoJev	2,086	MIT	Qwen3-0.6B + decision heads	Real-time control loops
jevlike	1,255	MIT	Byte encoder or any frozen HF encoder	Training on your own label set

1. Laya: the one everybody starred

Laya is the flagship by a wide margin, and the only one of the five you install with a single pip install laya. Convai Innovations released it on September 18 under Apache 2.0, and its 421M parameters sit on a ModernBERT-large backbone with a decision head on top. A 322M multilingual checkpoint covers 100+ languages, and a Router picks between them by detecting the script in under a millisecond.

Published speed is 39.5 ms per question on a Tesla T4, or 7.2 ms with ten batched. I ran the README's quickstart on an M3 Pro with no GPU acceleration and measured 66 ms median over 20 runs for all three questions in one pass:

import laya

agent = laya.load("convaiinnovations/laya")

state = {
    "subject": "Duplicate charge on invoice #4411",
    "body": "We were billed twice for March. Please refund the duplicate today or we will cancel our plan.",
}

questions = {
    "department": {"type": "choice", "instructions": "Which department should handle this request?",
                   "criteria": {"billing": "invoices, payments, refunds",
                                "technical": "bugs, outages, system errors",
                                "sales": "pricing, new contracts"}},
    "urgency": {"type": "score", "instructions": "How urgent is this request?",
                "criteria": ["not urgent", "soon", "critical deadline or blocking issue"]},
    "churn_risk": {"type": "noul", "instructions": "Does the user threaten to cancel or leave?"},
}

res = agent.predict(state, questions)["answers"]
print(res["department"]["choice"], res["department"]["confidence"])  # billing 0.827
print(res["urgency"]["score"], res["churn_risk"]["noul"])             # 1.49 0.741

Version 0.3.7 cut checkpoint loading roughly tenfold, taking laya.load() on this machine from 28 seconds to about 4, and added laya-serve, a FastAPI server on the same POST /v1/systemone protocol as Jev.

Now the part the star count hides. Laya's README is unusually candid: its base checkpoints score 0.362 and 0.342 on the typed-decisions benchmark against a 0.318 random baseline and a 0.461 majority-class baseline. The headline 0.766, which beats Jev's published 0.727, comes from laya-typed-decisions, fine-tuned on that benchmark's own training split. Treat Laya as a fast base you specialise on your own data, not a zero-shot replacement. It is also weak on large option sets: 0.425 against Jev's 0.870 on Banking77's 77 labels, because the options share a fixed 192 to 256 token budget and each label gets three or four tokens.

2. Kev: the drop-in with the honest evals

Kev is a family of rank-16 LoRA adapters plus a small pointer head on Qwen3.5 bases at 0.8B, 4B and 9B, from Jared Palmer. It serves TypeSafe's own POST /v1/systemone contract, so the official typesafe-sdk works against it by changing a base URL. Its Hacker News thread pulled 438 points, much of it arguing about whether any of this beats a fine-tuned BERT. Standing it up and querying it looks like this, run here on the M3 Pro:

git clone https://github.com/jaredpalmer/kev.git && cd kev
uv sync --extra serve
KEV_DTYPE=bf16 uv run --extra serve python -m kev.serve --run jaredpalmer/kev-0.8b --port 8009

curl -s localhost:8009/v1/systemone -H 'content-type: application/json' -d '{
  "state": "Shoes arrived two weeks late and in the wrong size. Also I see two charges on my card.",
  "model": "kev-latest",
  "questions": {
    "department": {"type": "choice", "instructions": "Which team should handle this?",
                   "criteria": {"returns": "Exchanges, refunds, wrong or damaged items",
                                "shipping": "Delivery status, delays, lost packages",
                                "billing": "Charges, invoices, payment problems"}},
    "escalate":   {"type": "noul", "instructions": "Does this need urgent human attention?"},
    "frustration":{"type": "score", "instructions": "How frustrated is the customer?",
                   "criteria": ["Calm", "Frustrated", "Very angry"]}
  }}'

That returned returns at 0.39 probability with shipping at 0.38 and billing at 0.24, the right spread for a ticket that mentions all three. Kev shipped an MLX backend on September 22, and on a Mac it is a large difference: the same request went from 213 ms on the old PyTorch MPS path to 77 ms on a fresh state and 47 ms on a repeated one, after a 3.2 s first call.

Kev publishes the most careful evaluation of the group, including where it loses. Kev-9B scores 0.822 on held-out new sources against Jev's 0.857, its confident-error rate is 4.0% against 3.7%, and the share of decisions you could automate at a 5% error budget is 0.45 to 0.57 against Jev's 0.70. Knowledge questions are the big gap, MMLU 0.74 against 0.90, and that is the base model, not the adapter.

3. SemIf: no new model, just read the logits

SemIf, formerly called OpenJev, does not pretend to have reproduced Jev's model. It reproduces the pattern: take a frozen open-weight model you already host, declare your options, and read their probabilities off the logits without sampling a single answer token.

The case for it runs on one RTX 3090 with a frozen Qwen3.5-4B, one state and 21 binary criteria. Direct typed logits: 1.023 s, zero output tokens. An autoregressive JSON array of the same 21 answers: 5.332 s and 111 output tokens, 5.21x longer. Reusing one long state across many criteria pushes throughput from 2.33 decisions per second to 20.03.

On quality, the 4B baseline reaches 0.845 modal agreement with TypeSafe's published results on a 102-row aligned subset against Jev's 0.883, and a quantized Qwen3.8-27B bridge hits 0.958 balanced accuracy on 144 authored decisions. Fixtures, prompt hashes and raw timings are all committed. It wants a GPU that holds a 4B model in BF16, but there is a llama.cpp CPU backend, MLX and MPS for Apple Silicon, and a WebGPU demo in a browser tab.

4. NanoJev: 0.6B for real-time loops

NanoJev is the outlier, and the only project here that clearly beats Jev at something. It is a Qwen3-0.6B backbone with decision heads trained on four game environments, aimed at the control-loop case behind TypeSafe's own Doom demo.

On the held-out test set, one shared checkpoint scores 128/128 successes on ViZDoom Basic against Jev's 56/128, and 27/128 on the harder Predict Position task against Jev's 11/128. It solves a 50x50 maze in 225 attempts where Jev needs 2,738. Jev still wins the maze test set 7/10 to 4/10, and they tie 8/8 on Snake.

Read that for what it is: a model trained on 18,760 decision questions from four games and evaluated on those same four games, with weights and dataset on Hugging Face under the unified-games-v1 tag. Strong evidence that a 0.6B purpose-trained model can outrun a frontier decision API inside a tight loop, and no evidence it will triage your tickets. The inference script expects CUDA, so there is no Apple Silicon path today.

5. jevlike: train your own from scratch

jevlike is not a model, it is a recipe. The architecture fits in a sentence: each option becomes a query vector, that query attends over the context tokens, a shared dot product scores each option-context pair, and a softmax across the options gives the distribution. The default encoder learns byte embeddings from scratch, or you bolt the head onto any frozen Hugging Face encoder.

Your data is one JSON object per line, {"context": "...", "options": [...], "label": 0}, and the loop is four commands on CPU, MPS or CUDA. Evaluation prints top-1 accuracy, calibration error, and a shuffled-context control that pairs each menu with the wrong context, the kind of baseline most projects skip.

It is the right pick when the options are yours: internal routing categories, a product taxonomy, a set of playbook actions. It is the wrong pick if you need something working this afternoon, and the author is upfront: the shipped chess checkpoint loses 48 of 50 games to Stockfish at level 0, and the default byte encoder truncates context to 192 bytes.

What the independent benchmark says

Every project above benchmarks itself against Jev on a suite it chose, and every one wins on its own suite. The useful number comes from elsewhere. The jabr classifier benchmark runs 49 tasks and 869 cases across compliance, triage, legal, DevOps, linguistics and safety:

System	v2 macro accuracy (49 tasks)
TypeSafe Jev (hosted)	0.966
Von (395M, open)	0.704
GLiNER2 (~300M, open)	0.698
Laya (421M, open)	0.583

That is a 26-point gap on out-of-domain tasks, with a distinct failure mode recorded for each: Von collapses to one mode on unfamiliar domains, GLiNER2 over-triggers on keywords, Laya compresses rating scales. Note that Von (546 stars, Apache-2.0, ModernBERT-Large) leads the open field despite sitting far below Laya on stars, a reminder that stars measure attention, not accuracy. In-domain, after a fine-tune on your own labels, the open models are competitive. Out of domain and zero-shot, they are not close yet.

Testing a local decision server from outside your machine

Kev, SemIf, Von and now Laya all expose an HTTP endpoint bound to your own machine, which is fine until something outside it has to call: a staging app, a webhook feeding the classifier, a teammate checking the routing, or a router sending small decisions to the cheap model. With Kev listening on port 8009, one command gives it a public HTTPS URL using Pinggy:

ssh -p 443 -R0:localhost:8009 free.pinggy.io

That matters during a migration, because the honest way to choose between these models is to shadow real traffic against both: point a copy of production webhooks at the tunnel, log what the open model would have decided, and compare it with Jev's actual answer. One caution: both servers are open by default, so set KEV_API_KEY or LAYA_API_KEY to require a bearer token before you expose one.

Which one to pick

For the shortest path from a hosted Jev call to a self-hosted one, use Kev: the wire API matches and your code does not change. If you already run an open-weight model, use SemIf and read the logits off what you have. If you want something small and CPU-friendly with multilingual coverage and will fine-tune, use Laya. If your decisions live inside a tight control loop, NanoJev is the only project here with evidence at that latency. If your label set is unusual enough that no pretrained checkpoint helps, jevlike trains one on a laptop.

Three others are worth a bookmark: OpenJev runs DiffusionGemma 26B-A4B and is the only one that answers questions about images, openjev-sglang serves Qwen3.6-35B-A3B on SGLang for B200-class hardware, and Von leads the independent benchmark.

Conclusion

The open ecosystem reproduced Jev's interface in about a day and has spent the week since trying to reproduce its accuracy. On latency, price and control it already wins outright: a 421M encoder on your own CPU costs nothing per call and answered in 66 ms on the laptop I tested it on. On zero-shot, out-of-domain quality it does not, and 0.966 against 0.704 is the number to remember when someone calls one of these a drop-in replacement.

So pick the one whose deployment story matches yours, fine-tune it on a few hundred of your own labelled examples, refit the confidence temperature, and measure it against what you run today. These projects are barely a week old and move fast enough that a figure goes stale in a day, so treat every published number, the vendor's included, as a hypothesis rather than a result, the same caution that applies to self-hosting models generally.

Reference

Best Open Source Jev Alternatives: 5 Self-Hosted Decision Models

Let AI Control Your Desktop: The Best Computer Use MCP Servers in 2026

Saptarshi Paul — Fri, 02 Oct 2026 12:01:54 +0000

Most software still has no API. Design tools, hardware control panels, the iOS Simulator, old enterprise apps, and half the settings screens on your laptop only speak mouse and keyboard. That is exactly where AI agents used to stop being useful. Computer use MCP servers close that gap by exposing screenshots, clicks, typing, and window management as tools over the Model Context Protocol, so Claude Code, Codex, Cursor, or any other MCP client can drive a real desktop. In 2026 the category matured quickly: Anthropic shipped a built-in computer-use server in Claude Code, OpenAI shipped background computer use in Codex on April 16, 2026, and Windows-MCP claims over 2 million users through Claude Desktop Extensions. Below are the servers worth installing, with the tool counts each one reported when I connected to it and the tradeoffs the READMEs skip.

Quick Summary

If you are already on Claude Code on a Mac, enable the built-in computer-use server from the /mcp command. It is a research preview for Pro and Max plans, macOS only in the CLI, and interactive sessions only. See the Claude Code docs.

Best computer use MCP servers in 2026 (GitHub stars, September 24, 2026):

Cua Driver (~26.2k, MIT): macOS, Windows, Linux; background input; CLI + MCP + SDKs.
Windows-MCP (~7.2k, MIT): the default for Windows; accessibility-tree based; works with any LLM.
Peekaboo (~5.2k, MIT): deepest macOS toolset, 24 MCP tools.
Open Computer Use (~2.2k, MIT): open-source take on Codex computer use for macOS, Linux, Windows.
computer-use-linux (~600, MIT): Wayland-first Linux desktop control in Rust.
computer-use-mcp (~380, MIT): one computer tool mirroring Anthropic's API tool.
macOS-MCP (~190, MIT): lightweight Mac server with built-in HTTP transport and auth.

Prefer accessibility trees over pixels. Servers that read the OS accessibility tree (Windows-MCP, Peekaboo, Open Computer Use, Cua Driver) are faster, cheaper in tokens, and far less flaky than clicking screenshot coordinates.

For browser tasks, skip desktop control. Chrome DevTools MCP and Playwright MCP are more reliable for web automation.

For remote desktops, run an HTTP-capable server such as macOS-MCP or Windows-MCP with a bearer token, expose it with ssh -p 443 -R0:localhost:8000 free.pinggy.io, and add the HTTPS URL to your MCP client.

What a Computer Use MCP Server Actually Does

A computer use server is a local process that turns your desktop into MCP tools. The agent calls something like screenshot to see the screen, then click, type_text, or press_key, and the server performs the OS-level work: Accessibility API on macOS, UI Automation on Windows, AT-SPI on Linux.

The key differences is how the server describes the screen. First-generation servers, modeled on Anthropic's computer use tool, send a screenshot and expect the model to return pixel coordinates. That works but costs image tokens on every step and breaks when a window moves. Newer servers read the accessibility tree (the same structure screen readers use) and give the model a list of real buttons and fields with stable IDs. Most servers below use the tree when the app exposes one and fall back to pixels for canvases, games, and poorly labeled Electron apps.

All of them require two OS permissions on macOS: Accessibility (to click and type) and Screen Recording (to see), granted to whichever app launches the server, usually your terminal.

Comparison of the Best Computer Use MCP Servers

Server	Platforms	How it sees	Transport	Best for
Claude Code computer-use	macOS (CLI)	Screenshots	Built in	Pro/Max users testing native apps
Cua Driver	macOS, Windows, Linux	Accessibility + screenshots	stdio	Cross-platform agents and fleets
Windows-MCP	Windows 7 to 11	UI Automation tree, vision optional	stdio, SSE, HTTP	Anything on Windows
Peekaboo	macOS 15+	Accessibility + screenshots	stdio	Deep Mac automation
Open Computer Use	macOS 14+, Linux, Windows	Accessibility	stdio	Codex-style computer use in any client
computer-use-linux	Linux (Wayland, X11)	AT-SPI + screenshots	stdio	GNOME, KDE, Hyprland, i3, COSMIC
computer-use-mcp	macOS, Windows, Linux	Screenshots	stdio	Anthropic-style tool, zero config
macOS-MCP	macOS 12+	Accessibility tree	stdio, SSE, HTTP	Remote Macs over HTTP

1. Claude Code's Built-in Computer-Use Server

If you already use Claude Code on a Mac, start here. Computer use ships as a built-in MCP server named computer-use that is off by default. Run /mcp in an interactive session, select computer-use, choose Enable, and grant Accessibility and Screen Recording the first time Claude reaches for the screen. The setting persists per project.

The guardrails are the most thoughtful of anything on this list. Claude has to ask before controlling each app in a session, and the prompt flags apps with broad reach: terminals and IDEs are marked "equivalent to shell access", Finder "can read or write any file". Browsers and trading platforms get view-only access, terminals and IDEs are click-only. Other apps are hidden while Claude works, your terminal is excluded from screenshots, Esc aborts from anywhere, and only one session can hold the computer at a time.

The limits are real, though. It's a research preview, macOS only in the CLI (the Claude Desktop app also covers Windows), Pro or Max only (not Team or Enterprise), needs a claude.ai login rather than Bedrock or Vertex, and doesn't work with claude -p, so it's out for CI. Claude also tries MCP servers, Bash, and Claude in Chrome first, and falls back to the screen only when nothing more precise fits.

2. Cua Driver

Cua (~26.2k stars, MIT) is the biggest open-source project in computer use, and Cua Driver is the piece that gives an agent native desktop tools on macOS, Windows, and Linux through a CLI, MCP, or typed SDKs. Its headline feature is background delivery: where the app and platform allow it, the agent works without moving your pointer or stealing focus. Install it with the official script, then register it:

/bin/bash -c "$(curl -fsSL https://cua.ai/driver/install.sh)"
claude mcp add --transport stdio cua-driver -- cua-driver mcp

cua-driver mcp-config --client codex or --client cursor prints the right snippet for other clients. The same repo has Lume for macOS and Linux VMs on Apple Silicon and Cua Fleets for cloud desktops. The tradeoff is scope: it's a platform, and a one-line npm server is simpler for clicking through one app.

3. Windows-MCP

Windows-MCP (~7.2k stars, MIT) is the default choice on Windows, and the most-installed server here: its README reports over 2 million users through Claude Desktop Extensions. It reads the Windows UI Automation tree rather than relying on computer vision, so it works with any LLM, vision or not. The project quotes 0.2 to 0.5 seconds between actions. Install it with uv and add it to Claude Code:

claude mcp add --transport stdio windows-mcp -- uvx windows-mcp serve

Beyond Screenshot, Snapshot, Click, and Type, it ships Clipboard, Process, FileSystem, Registry, and PowerShell. That last group is the risk: an agent with PowerShell and Registry can do anything you can, so trim it with --exclude-tools "PowerShell,Registry" or allow-list with --tools "Screenshot,Click,Snapshot". It also runs over SSE or streamable HTTP with --auth-key, an IP allowlist, TLS, and OAuth 2.0 with PKCE, which makes it the best option for driving a Windows box from elsewhere.

4. Peekaboo

Peekaboo (~5.2k stars, MIT), from Peter Steinberger and now under the OpenClaw org, is the most complete macOS option. It's a CLI, a menu-bar app, and an MCP server over one toolset. Version 4.5.0 reported 24 MCP tools when I connected to it, including see, click, type, press, window, menu, dock, dialog, space, clipboard, and set_value. You call see first to get a UI map with element IDs, then act on those IDs.

{
  "mcpServers": {
    "peekaboo": { "command": "npx", "args": ["-y", "@steipete/peekaboo", "mcp"] }
  }
}

It needs macOS 15 or later and Node.js 22 or later. It only speaks stdio today: the HTTP and SSE flags are recognized but, per its own docs, not implemented yet. Remote use is not an option.

5. Open Computer Use

Open Computer Use (~2.2k stars, MIT) exists because OpenAI's Codex computer use is good and closed. It rebuilds that accessibility-driven, non-intrusive approach as an MCP server for macOS 14+, Linux, and Windows. Version 0.3.5 exposed nine tools when I connected: list_apps, get_app_state, click, drag, scroll, type_text, press_key, set_value, and perform_secondary_action.

npm i -g open-computer-use
open-computer-use install-claude-mcp   # or install-codex-mcp, install-gemini-mcp, install-opencode-mcp

On macOS, run open-computer-use once first to grant the two permissions. ocu call list_apps runs one tool from the shell to check permissions.

6. computer-use-linux

Most servers here are Mac or Windows first. computer-use-linux (~600 stars, MIT) is a Rust server that actually handles Wayland, using the RemoteDesktop and Screenshot portals with ydotool as a fallback. It targets windows on GNOME, KDE/KWin, Hyprland, i3, and COSMIC, and accepts AT-SPI role/name selectors instead of raw coordinates.

npm install -g @agent-sh/computer-use-linux
computer-use-linux doctor | jq .readiness

doctor returns one JSON report of which backend works on your compositor and what is blocking the rest. Expect some setup, since AT-SPI and portals vary by distro.

7. computer-use-mcp

computer-use-mcp (~380 stars, MIT) is the simplest server on the list. Start it with npx -y computer-use-mcp and it exposes exactly one tool, computer, a near copy of Anthropic's computer use API tool, implemented with nut.js. The author recommends a small resolution such as 720p and the Rango browser extension, so the model navigates the web by keyboard instead of guessing coordinates. The README's own warning is blunt too: treat it "like giving a hyperactive toddler access to your computer."

8. macOS-MCP

macOS-MCP (~190 stars, MIT) comes from the Windows-MCP team and carries the same design to the Mac: accessibility-tree snapshots, macOS 12+, and 12 tools (Snapshot, Click, Type, Scroll, Move, Shortcut, App, Desktop, Shell, Scrape, Wait, Notification). The README still shows uvx macos-mcp, but the current release needs the serve subcommand: uvx macos-mcp serve. Its real advantage over Peekaboo is transport: it serves streamable HTTP with bearer auth, which is exactly what you need to control a Mac that isn't the one you're sitting at.

When the Task Lives in a Browser

If everything the agent needs is inside a web page, a desktop server is the wrong tool. Chrome DevTools MCP (~52.6k stars) exposed 30 tools in my test, including network requests, console messages, and Lighthouse audits. Playwright MCP (~37.5k stars) exposed 25 and works from structured accessibility snapshots, so no vision model is needed. Adding it is one line: claude mcp add playwright npx @playwright/mcp@latest. Both are more reliable than steering a browser window by screenshot.

Controlling a Remote Machine with Pinggy

Stdio servers only work on the machine running the agent. To drive a lab Mac, a test Windows PC, or a VM somewhere else, run a server that speaks HTTP and put a tunnel in front of it. Here is the setup I tested with macOS-MCP. Windows-MCP takes the same serve flags.

On the machine you want to control, generate a token and start the server on localhost:

export MCP_KEY=$(openssl rand -hex 32)
uvx macos-mcp serve --transport streamable-http --host 127.0.0.1 --port 8000 --auth-key "$MCP_KEY"

In a second terminal, open a Pinggy tunnel to that port:

ssh -p 443 -R0:localhost:8000 free.pinggy.io

Pinggy prints a public HTTPS URL. On the machine running the agent, register it with the same token:

claude mcp add --transport http remote-mac https://<your-pinggy-url>/mcp --header "Authorization: Bearer <MCP_KEY>"

Through the tunnel, a request without the header got 401, and with it tools/list returned all 12 tools. Always keep the token on: this URL controls a whole computer. Free tunnels expire after 60 minutes, and a Pinggy Pro token gives you a persistent URL. If you are writing these configs by hand for several clients, the MCP server config generator can build the JSON for Claude Desktop and Claude Code, including HTTP servers with headers.

How to Choose

Pick by operating system first. Claude Code on a Mac: the built-in server, plus Peekaboo when you need more. Windows: Windows-MCP. Linux: computer-use-linux. All three, or cloud desktops: Cua Driver. A remote machine: macOS-MCP or Windows-MCP over HTTP.

Whichever you choose, disable servers you aren't using, since every tool definition costs context, and treat anything on screen as untrusted input: a web page or email can carry text written to steer the agent. Use a separate user account or a VM when the task allows it.

Conclusion

Computer use over MCP is finally practical, mostly because the good servers stopped guessing pixels and started reading accessibility trees. Use the built-in server on Claude Code with Pro or Max, Windows-MCP on Windows, Peekaboo for deep Mac work, and Cua Driver across all three. Keep browser work in Playwright or Chrome DevTools MCP, and never expose a desktop-control endpoint without a token in front of it.

Reference

Stop Toggling Apps: Why AI Workspaces Are the New Stack

Saptarshi Paul — Fri, 02 Oct 2026 10:09:17 +0000

Think about the last project you finished. You probably researched in a browser, took notes in one app, ran numbers in a spreadsheet, built slides in another tool, generated images somewhere else, and asked a chatbot for help in yet another tab. Each tool worked. But a surprising amount of your day went to moving information between them.

That pattern is starting to change. A growing number of professionals and teams are replacing sprawling tool stacks with one AI workspace, a single environment where an AI agent can research, write, analyze data, design, and deliver finished work. This article covers what is driving the shift, what the research says about the real cost of app switching, and how to decide whether consolidating makes sense for you.

Summary

App switching adds up. A 2022 Harvard Business Review study of 137 workers found nearly 1,200 app and website toggles a day per person, costing just under four hours a week, or about 9% of the working year.
The first wave of generative AI made it worse. Teams added a chatbot, a writing assistant, an image generator, a video tool, and a note-taker, each with its own login and bill.
An all-in-one AI workspace is agentic. You describe the outcome, one agent plans the steps, and hands back finished files such as documents, spreadsheets, and slide decks. Context carries from one task to the next.
Choose on outputs, not demos. Look for downloadable files, persistent context, a plan you can review, clear data policies, export options, and transparent pricing. Pilot one recurring workflow for two to four weeks first.
Keep specialist tools where they earn it: complex financial models, pixel-level design, and systems a regulator requires. The goal is less switching, not zero apps.

The hidden cost of the modern tool stack

App switching feels harmless because each switch takes a moment. The problem is volume. In a study published in Harvard Business Review in 2022, researchers tracked 137 workers across 20 teams at three Fortune 500 companies for up to five weeks. The average worker toggled between apps and websites nearly 1,200 times a day.

Each switch cost only a little over two seconds, but those seconds add up fast. The researchers estimated that workers spent just under four hours a week reorienting themselves after switching. That is roughly five working weeks a year, or about 9% of annual working time.

Time is only part of it. Gloria Mark, a professor of informatics at the University of California, Irvine, has spent years studying workplace interruptions, and her research found it can take more than 20 minutes to fully get back to an interrupted task. Business professor Sophie Leroy coined the term attention residue in a 2009 study to describe what happens when part of your mind stays on the previous task after you switch. So every jump between tools can leave you a little less focused on the work in front of you.

Multiply that across a team of 10 or 50 people, and the cost of a fragmented tool stack gets hard to ignore.

How we ended up with so many apps

The modern tool stack did not appear overnight. Over the past 15 years, software moved toward a best-of-breed model, where each product solves one job very well. Teams adopted a writing tool, a design tool, a project management tool, a spreadsheet tool, a presentation tool, and a communication tool, then relied on integrations to connect them.

Integration platforms helped, but they added their own complexity. Every automated workflow became one more thing to configure, maintain, and troubleshoot whenever an app changed its interface or its pricing.

Ironically, the first wave of generative AI made the problem worse. Instead of cutting the number of tools, it added more. Many teams now pay for a chatbot, an AI writing assistant, an AI image generator, an AI video tool, and an AI note-taker, each with its own login, subscription, and learning curve. The result is more capability and more fragmentation.

What an all-in-one AI workspace actually is

An all-in-one AI workspace is a single environment where one AI agent handles many kinds of work from the same conversation. Instead of opening a separate application for each output, you describe what you need and the workspace produces it, whether that is a research report, a document, a spreadsheet, a slide deck, an image, a video, or a website.

That is different from a traditional software suite. A suite bundles separate applications under one brand, but you still move between them and carry the context yourself. It is also different from a standard chatbot, which can explain how to build a spreadsheet but usually cannot hand you a finished, working file.

What makes it a true AI workspace is that it is agentic. You describe an outcome, and the agent plans the steps, picks the right tools, does the work, and delivers a result you can review, edit, and download. Because everything happens in one place, the context from your earlier requests carries into the next task.

The model is especially useful for small teams, solo founders, freelancers, and students. They rarely have dedicated specialists for design, data analysis, or research, so a single workspace that covers all three can noticeably expand what one person gets done in a day.

Why tool stacks are losing ground

A few forces are pushing teams toward consolidation, and each one targets a specific weakness of the traditional tool stack.

Context stays in one place

In a fragmented stack, context lives in your head. You remember which spreadsheet has the latest numbers, which document holds the approved messaging, and which folder has the brand assets. In a unified workspace, the agent can reference your earlier work, uploaded files, and stated preferences, so you spend less time re-explaining the project every time you start a new task.

AI agents handle the handoffs

Most wasted time in knowledge work happens between tasks, not during them. Copying figures from a PDF into a spreadsheet, turning that data into charts, and moving the charts into slides are all handoffs. An agentic workspace can run those steps in sequence, which removes much of the manual transfer work that fills the average day.

Simpler costs and administration

Subscription sprawl is expensive and hard to manage. Every extra tool brings a license fee, a security review, an onboarding process, and another set of permissions to maintain. Folding several AI subscriptions into one platform can simplify budgeting and take some of the administrative load off IT and operations teams.

Finished output, not just answers

Early AI tools were mostly advisory. They answered questions and offered suggestions, but you still had to build the final deliverable yourself. Today's AI workspaces are designed to produce the deliverable itself: a formatted document, a working spreadsheet, or a presentation ready for review. That shift from advice to execution is the main reason consolidation now feels practical rather than theoretical.

A real-world example: one project, before and after

Take a common task: preparing a quarterly business review for a small company.

The tool stack approach. You research market trends in a browser with a dozen tabs open. You download sales figures as PDFs from your accounting system and retype them into a spreadsheet. You write formulas, fix the inevitable errors, and build charts. Then you open a document editor to write the summary, switch to a presentation tool to build slides, and visit an image generator for visuals. Along the way, you toggle between apps hundreds of times.

The unified workspace approach. In an agentic platform such as ImagineArt's Imagine Computer, you start by asking the agent to research recent trends in your market and summarize them with sources. Next, you upload the PDF sales reports and ask the built-in AI spreadsheet maker to turn them into an organized Excel file with working formulas and quarter-over-quarter comparisons. Finally, you ask the same workspace to turn the findings into a written summary and a slide deck.

You still review every output, check the numbers, and refine the messaging. The difference is that you direct the work from a single conversation instead of rebuilding context across six separate tools.

Where spreadsheets fit in a consolidated workspace

Spreadsheets deserve special attention because they sit at the center of so many workflows. Budgets, sales pipelines, project trackers, inventory lists, and gradebooks all live in spreadsheets, yet building a reliable one still takes formula knowledge that a lot of people do not have.

An AI spreadsheet maker changes that. Instead of choosing functions and structuring columns yourself, you describe in plain language what the sheet needs to do. The AI spreadsheet generator in ImagineArt's Imagine Computer, for example, can work from a prompt, a PDF, or raw data, then write the columns, fill in working formulas, and hand back a downloadable .xlsx file. It also offers templates for common needs such as budgets, trackers, gradebooks, and pipelines.

A simple prompt shows how this works in practice:

Create a monthly marketing budget for a five-person team with planned spend, actual spend, variance by channel, and a summary row that flags any line more than 10% over budget.

A capable AI spreadsheet maker should return a structured file with those columns, the variance formulas, and the flagging logic already in place.

When the spreadsheet lives in the same workspace as your research and documents, the numbers can flow straight into reports and presentations without manual copying. That said, always verify an AI-generated spreadsheet before you rely on it. Spot-check the totals, review the key formulas, and confirm the source data was captured correctly.

What to look for when choosing one AI workspace

Not every platform that claims to be all-in-one delivers on it. Before you consolidate, check each option against these criteria:

Real, downloadable outputs, such as documents, spreadsheets, and slide decks, rather than text you have to reformat elsewhere.
Persistent context, so the agent remembers your projects, files, and preferences across sessions.
Integrations with the tools you cannot replace, such as email, cloud storage, and team chat.
A plan you can review, so you can approve or edit the agent's steps before it runs them.
Clear data privacy and security policies, including how your files are stored and whether they are used for training.
Export options that let you take your work elsewhere, which protects you from vendor lock-in.
Transparent pricing that makes it easy to compare the platform's cost against your current subscriptions.

Run a short pilot before you commit to a platform. Pick one recurring workflow, do it in the new workspace for two to four weeks, and compare the time spent and the quality of the results against your current process.

When a specialized tool still makes sense

Consolidation is not the right answer for every situation. Financial analysts building complex models may still need the advanced features of a dedicated spreadsheet application. Professional designers may prefer specialized design software for pixel-level control. And teams in regulated industries may be required to use specific approved systems.

For most teams, the practical approach is a hybrid. Use one AI workspace for most everyday research, writing, data, and presentation work, and keep a small number of specialized tools for the tasks that genuinely need them. The goal is not to eliminate every app. It is to eliminate unnecessary switching.

How to make the transition without disrupting your team

Start by auditing your current stack. List every tool your team uses, what it costs, and which workflows depend on it. You will likely find overlapping subscriptions, and tools that only one or two people use.

Next, find the workflows with the most handoffs, such as reporting, content production, or client proposals. Those are the best candidates for consolidation because they offer the largest time savings. Migrate one workflow at a time, document the new process, and gather feedback before expanding. Finally, retire redundant tools gradually so no one loses access to important files.

Measure the results as you go. Track the hours spent on each migrated workflow, the number of tools involved, and the quality of the final output. Those simple metrics make it easier to justify further consolidation, or to pull back if a workflow performs better in its original tool.

Final thoughts

The tool stack era solved real problems, but it also created a hidden tax on focus, time, and budgets. As AI agents get better at producing finished work across formats, the case for juggling a dozen disconnected apps gets weaker every year.

Consolidating into one AI workspace will not remove the need for human judgment, careful review, or the occasional specialized tool. What it can remove is the constant switching that fragments your attention. For teams that want to spend less time moving information around and more time on meaningful work, the end of app switching may already be here.

Reference

The End of App Switching: Why All-in-One AI Workspaces Are Replacing Tool Stacks