AI agents with browser control have been getting a lot of attention over the past couple of months. We now have different versions of these tools from OpenAI’s browser agent to Perplexity Comet, OpenClaw, and many others.

Subscribe now

I have tried a handful of them, and while they are useful, there are still clear limits to what they can actually do. Sometimes I ask an agent to complete a web task, and it starts fine, only to fail midway because of CAPTCHAs, authentication, login issues, or some random website behavior it cannot handle properly.

One tool that I find really interesting and stands out among those that I tried is called BrowserAct. It gives agents a more reliable way to use the web, extract live data, take browser actions, and complete real tasks from end to end.

In this guide, I’ll describe what BrowserAct is, show you how it works, and discuss how you can take advantage of it.

Let’s get started.

What is BrowserAgent?

BrowserAct is a browser automation tool built for AI agents.

The easiest way to think about it is this: instead of giving your AI agent a normal text-only search tool, BrowserAct gives it a real browser it can control from the terminal.

It can open pages, read what is on the screen, click buttons, type text, extract information, inspect page state, manage sessions, and continue working through multi-step web tasks.

The real value is in how BrowserAct handles the messy parts of the web.

If you keep an eye in the latest AI news, you’d know that a lot of popular browser agents only work well in clean demo environments. Ask them to open a simple page and click a button, and they look impressive. But once you try them yourself in a real working environment, things start to get messy.

Pages load dynamically. Login sessions expire. Buttons move in random places. Websites detect automation. CAPTCHAs appear. Some pages need your existing Chrome profile. Some tasks need a human to step in for a few seconds.

I mean… it’s an annoying experience.

BrowserAct is designed around those problems.

It gives agents different browser modes depending on the task. You can use a normal Chrome-based browser, control your current Chrome session directly, use stealth browsers for protected public pages, or create separate browser identities for account-based work.

Key features of BrowserAct

BrowserAct has a lot of features, but these are the ones that matter most if you are using it with an AI agent.

• Real browser control from the terminal: BrowserAct lets agents open websites, inspect the page, click buttons, type into fields, and continue through multi-step browser tasks directly from the CLI. This makes it useful for Claude Terminal, Cursor, Codex CLI, and other agentic coding tools that can run shell commands.

• Multiple browser modes: BrowserAct supports different browser setups depending on the task. You can use a normal Chrome-based browser, import a local Chrome profile, control your current Chrome session directly, or use stealth browsers for public pages that are harder to access with basic scraping tools.

• Page extraction for research: For simple research tasks, BrowserAct can extract rendered web pages as Markdown or HTML. This is useful when you need clean notes from product pages, docs, pricing pages, changelogs, or JavaScript-heavy websites.

• Support for logins and sessions: BrowserAct can reuse browser state through Chrome profiles or direct Chrome control. This is helpful when the task needs access to a logged-in dashboard, account page, admin panel, or internal tool.

• CAPTCHA solving and human handoff: If a task gets blocked by a CAPTCHA, 2FA, or another manual step, BrowserAct can either attempt solving or create a remote assist link so a human can complete the step.

• Reusable scraping skills: BrowserAct also has Skill Forge, which helps agents turn repeated browser workflows into reusable skills. This is useful when you do not want the agent to rediscover the same website structure every time.

These are just some of the things the platform can do. I encourage you to go to the skills page and explore other capabilities.

How to install BrowserAct

BrowserAct has two main parts.

• The first is the CLI itself. This performs the actual browser automation.

• The second is the entry skill. This tells your AI agent when and how to call the CLI.

If you are using an agent that supports skills, the easiest path is to ask your agent to install it for you.

Open a Claude code instance and paste the following commands:

Install browser-act.
Skill URL: https://github.com/browser-act/skills/tree/main/browser-act
After installation, verify that the CLI is available.

If you want to install it manually, you can use uv with Python 3.12:

# Install the BrowserAct CLI using uv and Python 3.12.
uv tool install browser-act-cli --python 3.12
# Confirm that the command is available.
browser-act --version

Some BrowserAct features can work without an API key, especially basic Chrome and chrome-direct automation. But hosted features like stealth browsers, stealth extraction, dynamic proxy rotation, and CAPTCHA solving require an API key.

To get the API key, head over to the API keys page in your BrowserAct profile section and click on the Manage API Keys to create one.

You can start the login flow with:

# Start BrowserAct authentication.
browser-act auth login
# Poll until the login flow is complete.
browser-act auth poll

Or set your API key directly:

# Set your BrowserAct API key directly.
browser-act auth set <your_api_key>

Take note that Claude may ask for your permission to fetch several GitHub codes and also to allow some skills to execute.

Once all the necessary libraries and dependencies are installed, you should get this message in your Claude terminal.

Okay, you are now ready to use BrowserAct.

Example use case 1: Extract product information for article research

The first example I would show readers is a simple research workflow.

This is useful for writers, marketers, developers, and anyone who needs to collect information from live web pages. Since I write a lot of AI tool reviews and tutorials, this is the kind of task I can actually see myself using.

Let’s say I want to research BrowserAct’s homepage and pricing page, then save the results as Markdown so I can use them as notes for an article.

Command:

# Extract BrowserAct homepage content and save it as Markdown.
browser-act stealth-extract https://www.browseract.com/ --output ./browseract-homepage.md
# Extract BrowserAct pricing page content and save it as Markdown.
browser-act stealth-extract https://www.browseract.com/pricing --output ./browseract-pricing.md

Prompt for Claude Terminal:

Use BrowserAct to extract the BrowserAct homepage and pricing page.
Save both pages as Markdown files.
Then read the files and create a concise research summary with:
1. What BrowserAct does
2. Key features
3. Browser modes
4. Pricing details
5. Possible use cases for AI agents

This is a simple example, but it already shows the value. Instead of manually opening pages, copying text, cleaning the content, and pasting it into my notes, I can let the agent extract the rendered pages and turn them into a structured research summary.

Notice in the logs above, Claude loads the BrowserAct skill that we have installed earlier, uses stealth-extract to gather all relevant data, and sums it up into a markdown file.

This is the output result with full text below:

Research Summary (condensed)

  1. What it does — BrowserAct is an agent-native browser runtime: a real browser layer that lets AI agents use the live web
  reliably, getting past bot blocks and CAPTCHAs, isolating sessions, handling human hand-offs, and returning clean, low-token
  indexed data. Positioned as an advanced replacement for WebFetch/curl/selector scrapers, delivered as a CLI/skill for Claude
  Code, Cursor, Codex, Windsurf.

  2. Key features — stealth fingerprints + TLS rotation + residential proxies; automatic CAPTCHA solving (reCAPTCHA, Cloudflare
  Turnstile, DataDome, HUMAN); human-in-the-loop remote-assist; unlimited non-interfering concurrency; LLM-native runtime (clean
  State, command Actions, semantic Memory, Confirmation-Gate Safety); plus CLI, no-code cloud workflows, and API/MCP
  integrations (Make, n8n, Zapier).

  3. Browser modes — three types, all local-capable: chrome (imports local login state, runs independently), chrome-direct
  (drives your live Chrome with extensions/SSO), and stealth (anti-detection, undetectable even headless). Stealth adds private
  mode, fixed-identity mode, and dynamic/static proxies. A lightweight stealth-extract path handles read-only parallel
  extraction (what I used here).

  4. Pricing — Free Trial ($0, 100 daily credits, 5 local browsers) → Basic $13/mo (10K credits, 10 tasks) → Essential $56/mo
  (50K credits, 20 tasks, most popular) → Advanced $96/mo (100K credits, 40 tasks). Yearly saves 20%. Pay-as-you-go from the
  credit pool: dynamic proxy ~$3.2/GB, static proxy by tier, workflow steps ~$0.0032 each; Cloud Browser TBD. No credit card for
  trial.

  5. Use cases for AI agents — large-scale scraping past Cloudflare (the Amazon bestsellers demo), turning any site into an API,
  authenticated dashboard workflows via reused Chrome login, isolated multi-account matrices, competitive monitoring/research,
  human-assisted 2FA flows, and embedding web abilities into products via API/MCP.

  One caveat worth noting: figures like “99%+ CAPTCHA success,” “500M+ pages,” and “10K+ concurrent sessions” are BrowserAct’s
  own marketing claims from the homepage, not independently verified.

My thought here is that BrowserAct is very useful for writers who need live product data. A lot of AI tools update their pricing, model names, features, and limits all the time.

If you are writing a review or comparison article, you want to work from current pages, not old assumptions.

Example use case 2: Use Chrome to work with logged-in pages

The second example I would show is logged-in browser work.

This is where basic scraping tools usually fail because the page is behind an account. BrowserAct can help by importing a local Chrome profile into an isolated browser or controlling your current Chrome directly.

For example, let’s say I want the agent to open a dashboard I am already logged into and summarize the visible data.

First, list profiles:

# Find the local Chrome profile that contains the login state you need.
browser-act browser list-profiles

Then create a Chrome browser from that profile:

# Create a BrowserAct-managed Chrome browser from the selected local profile.
browser-act browser create \
  --type chrome \
  --name “dashboard-research” \
  --desc “Logged-in Chrome profile for dashboard research” \
  --source-profile <profile_id>

Then use it:

# List BrowserAct browsers and copy the browser ID you want to use.
browser-act browser list
# Open the logged-in dashboard in a named session.
browser-act --session dashboard-check browser open <browser_id> https://example.com/dashboard
# Read the current page state.
browser-act --session dashboard-check state

Prompt for Claude Terminal:

Use BrowserAct with my logged-in Chrome browser called “dashboard-research.”
Open the dashboard page, inspect the visible page state, and summarize the key numbers.
Do not click destructive buttons.
If the page asks for 2FA or a manual verification step, use remote assist and wait for me to complete it.

This is a good example because it shows the more practical side of BrowserAct.

A lot of business workflows happen inside logged-in dashboards. Analytics tools, ad platforms, content management systems, SaaS admin panels, project management tools, and internal portals all live behind accounts.

A normal search tool cannot access those. A normal scraper should not be given raw credentials. BrowserAct gives the agent a browser-based path that can reuse existing login state and keep the task more controlled.

I would still be careful here. I would not tell an agent to roam freely inside sensitive accounts. I would give it a narrow task, ask it to avoid destructive actions, and use confirm-before-use for sensitive browsers when needed.

Example use case 3: Getting through human verification when standard automation fails

One practical difference between BrowserAct and a standard browser automation tool is how it handles human-verification challenges.

A normal automation script can open a page, wait for it to load, and click a few buttons. But once the website shows a CAPTCHA, bot check, or manual verification screen, the workflow often stops there.

For example, a simple Playwright-style script might look like this:

// A simple Playwright-style example.
// This can open the page, but it cannot reliably complete human verification on its own.
import { chromium } from “playwright”;
const browser = await chromium.launch({ headless: false });
const page = await browser.newPage();
await page.goto(”https://medium.com/me/stats”);
// The script can wait for the page to load.
await page.waitForLoadState(”networkidle”);
// But if the page shows a CAPTCHA or human verification challenge,
// the script usually gets stuck here unless you build a custom workaround.
const content = await page.textContent(”body”);
console.log(content);
await browser.close();

When I ran the command:

node playwright-verification-test.js

You can see that we are blocked and can’t get the necessary information.

This is not really a Playwright problem. Playwright is powerful, but it is still a developer-first automation tool. Modern websites often use browser fingerprinting, TLS checks, proxy reputation, JavaScript challenges, CAPTCHA pages, and other verification steps that interrupt basic automation.

BrowserAct approaches this with three layers.

The first is the environment layer. BrowserAct can run the task in a stealth browser environment with fingerprint spoofing, TLS rotation, and proxy switching. This helps the agent avoid some of the common signals that break standard automation.

The second is the execution layer. If I only need to extract content from a protected or JavaScript-rendered page, I can use one command:

# Extract a protected or JavaScript-rendered page as Markdown.
browser-act stealth-extract https://example.com/protected-page --output ./protected-page.md

If the session hits a supported CAPTCHA challenge, BrowserAct can attempt to solve it directly:

# Ask BrowserAct to solve a supported CAPTCHA challenge in the current session.
browser-act --session research-session solve-captcha

The third is the human layer. When the page needs 2FA, account confirmation, or manual review, BrowserAct can generate a live handoff URL:

# Generate a live URL so I can take over the browser from any device.
browser-act --session research-session remote-assist --objective “Complete the human verification step”

I can open the remote-assist link, complete the verification myself, and then let the agent continue in the same browser session.

Now, let’s access the same link using BrowserAct with this command:

browser-act stealth-extract https://medium.com/me/stats --output ./protected-page.md

All the personal stats on my Medium account got retrieved and summarized. This is super cool!

A standard automation tool often stops when a page asks users to “verify you are human.” BrowserAct gives the workflow more ways to continue. It can improve the browser environment, attempt CAPTCHA solving when supported, or hand the session to a real person when human judgment is needed.

For legitimate workflows like researching public pages, checking my own dashboard, testing my own website, or working inside an account I control, this makes BrowserAct feel more practical than basic browser automation. It does not pretend the web is clean and predictable. It gives agents a way to handle interruptions without losing the whole session.

Other use cases for BrowserAct

BrowserAct can be used for many practical workflows, especially when the task involves live web data or browser interaction.

Here are some examples I would include in the article.

1. AI research and article writing

This is the most obvious use case for me.

You can ask an agent to collect live information from product pages, docs, changelogs, pricing pages, GitHub repos, public directories, and comparison pages. Then the agent can summarize the results, pull out useful details, and save everything into Markdown.

This is helpful when writing long-form articles because it reduces the boring part of research. You still need to think, fact-check, and write the actual opinion, but the agent can gather the raw material faster.

2. Competitor research

You can use BrowserAct to monitor competitor websites, pricing pages, feature pages, landing pages, and product updates.

Example prompt: Use BrowserAct to visit these five competitor pricing pages. Extract plan names, monthly prices, yearly discounts, credit limits, and key restrictions. Put the results in a Markdown table. Also add a short note about what changed compared with my previous notes.

This is useful for SaaS founders, marketers, and indie hackers who need to keep track of what other products are doing.

3. QA testing for your own website

Another good use case is checking your own web app.

You can ask BrowserAct to open your website, click through important flows, check buttons, inspect forms, capture screenshots, and report anything broken.

Example prompt: Use BrowserAct to test my website homepage.
Open the page, inspect the visible state, click the main navigation links, and check if each page loads correctly. Do not submit any forms. Create a QA report with broken links, missing buttons, layout issues, and confusing copy.

This is not a replacement for full automated testing, but it is useful for quick checks. I can see this being helpful when launching a landing page, a new pricing page, or a new onboarding flow.

4. Lead research

BrowserAct can help collect public company information, product descriptions, contact pages, or directory listings.

Example prompt: Use BrowserAct to research AI startups from this public directory. For each company, extract the name, website, short description, category, and pricing page URL if available. Limit the result to 20 companies. Save the output as CSV.

Again, this should be done responsibly and only on pages where you are allowed to collect data. But for public research, it can save a lot of manual work.

5. Internal workflows

Some workflows are not about scraping at all. Sometimes you just need an agent to do repetitive browser work inside your own tools.

Examples:

• Open a dashboard and export a report.

• Check if a scheduled post went live.

• Update a small field in a CMS.

• Open several internal pages and summarize visible data.

• Review web forms before launch.

These are simple tasks, but they become annoying when you do them every day. BrowserAct gives agents a way to do those tasks through the browser instead of requiring a custom API integration for everything.

Why should you care?

I think the reason BrowserAct is interesting is because AI agents are moving from chat to action.

For the past few years, most AI tools were built around answering questions. That is useful, but the next step is getting agents to complete actual work. The browser is a huge part of that because so much work still happens inside websites and dashboards.

The problem is that browser automation is messy.

Traditional tools like Playwright and Puppeteer are powerful, but they are usually developer-first. You need to write scripts, maintain selectors, handle sessions, debug failures, and update code when the website changes.

AI browser agents are easier to use, but many of them still break when the task touches real-world friction like logins, CAPTCHAs, dynamic pages, or multi-step flows.

BrowserAct sits in an interesting middle ground.

It gives AI agents a structured browser tool they can call from the terminal. It supports browser state, sessions, indexed page elements, stealth extraction, CAPTCHA handling, remote assist, and reusable skills. It is still technical enough for developers and agent users, but it removes a lot of the manual work needed to build browser automation from scratch.

For me, the most useful part is not just automation. It is recoverability.

When something goes wrong, the agent has options. It can inspect the state again. It can use another browser mode. It can call CAPTCHA solving. It can request remote assist. It can continue from the same session after a human completes a verification step.

That is a big deal because failed browser tasks are usually where these agents become frustrating. BrowserAct does not make every website magically easy, but it gives the agent a better path through the messy parts.

BrowserAct pricing

BrowserAct’s pricing is based around infrastructure services and credits.

There is a free fingerprint browser option for the first five profiles. This includes unique browser profiles, full session and cookie isolation, and one-click proxy assignment.

Dynamic proxy usage is priced by credits per GB. BrowserAct lists dynamic proxy pricing at 5,000 credits per GB, with pricing as low as $3.20 per GB.

Static proxy pricing depends on location and tier. This is meant for dedicated long-term IPs, which are useful for account management and stable connectivity.

Workflow steps cost 5 credits per step, with the pricing page showing a rate as low as $0.0032 per step. These steps are tied to AI-powered task execution, remote browser scheduling, proxy support, and CAPTCHA solving.

My thoughts after trying BrowserAct

BrowserAct feels like one of those tools that makes more sense once you have already hit the limits of browser agents.

If you have only used agents for simple search or basic page summaries, it may look like another automation tool. But once you start asking agents to work with logged-in pages, dynamic websites, CAPTCHAs, dashboards, and multi-step tasks, the value becomes clearer.

What I really like is that BrowserAct is built for the messy web, not just clean demos. It gives agents a browser, but it also gives them sessions, state inspection, browser modes, profile import, stealth extraction, CAPTCHA handling, and human handoff.

I also like that it works from the terminal. Since I already use Claude Terminal for coding and research, BrowserAct fits naturally into that workflow. I can ask Claude to collect data, inspect a page, save Markdown files, compare changes, or test a website without manually building a scraper every time.

That said, I would still use it carefully.

Browser automation can touch sensitive accounts, private dashboards, and websites with strict rules. I would not give an agent broad access without clear limits. I would start with public pages, personal workflows, and accounts I own. For logged-in pages, I would keep the task narrow and avoid destructive actions unless I am watching closely.

BrowserAct is not a magic button that makes every website automation work perfectly. No tool can promise that. But it gives agents a better browser layer, and that is exactly what a lot of agent workflows need right now.

Final Thoughts

AI agents are becoming more capable, but they still need better tools to interact with the real web.

BrowserAct is one of the more practical tools I have tested because it focuses on the part where many agents still fail: using the browser properly. It can extract rendered pages, interact with websites, reuse Chrome sessions, manage isolated browsers, handle some CAPTCHA flows, and hand control to a human when needed.

For writers, it can help with research. For developers, it can help with browser testing and automation. For founders and marketers, it can help with competitor tracking, pricing checks, and data collection. For agent builders, it can become part of a larger automation stack.

I am still early in testing it, but I can already see why BrowserAct is useful. It gives AI agents a more reliable way to work with the web, and that is becoming more important as agents move from answering questions to completing real tasks.

If you are already using Claude Terminal, Cursor, Codex CLI, or other agent tools, BrowserAct is something I would test. Start with a simple extraction task. Then try a browser session. Then try a logged-in workflow. That is where you will start to see what it can actually do.

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

A lot of users, including myself, who rely on AI chatbots and coding agents for business and development workflows share one major concern: the cost and speed of token consumption.

Subscribe now

I use three chatbots for daily work: ChatGPT, Claude, and Gemini. The common problem is that what ChatGPT knows about me does not carry over to Claude or Gemini. I end up repeating the same information multiple times.

In my development workflows, I switch between Warp, Claude Code, and Codex. The biggest challenge is the number of tokens wasted by rebuilding the project context in each environment.

Founders and developers have long asked for a self-updating context layer for AI. Finally, we have one. It is called Unabyss.

What is Unabyss?

Unabyss is a personal context layer for your AI.

You connect your apps once, and Unabyss extracts and organizes your role, company, voice, and decisions into a vault that any AI tool can access through MCP.

There is no need to re-explain yourself to every new chatbot, agent, or IDE. You can also connect sources such as LinkedIn, X, Gmail, Notion, Slack, Google Drive, Calendar, GitHub, and more.

An extraction engine structures the information into clean, layered files like persona.md, voice.md, and company.md. These files are optimized for LLMs and agents. The vault updates automatically as your connected tools sync, keeping your context current without manual effort.

Unabyss tries to make this less messy by turning your connected data into a living context layer that your AI tools can pull from when needed.

What’s great about this new platform is that you don’t need to pay an upfront fee. New users receive $20 in free credits on signup, with no card required. After that, it uses pay-as-you-go pricing.

Note: Unabyss is live on Product Hunt today. You can check the launch here.

How Unabyss Works

Connect Your Sources

Start by connecting the apps you use most. Unabyss supports popular platforms like X, LinkedIn, GitHub, Gmail, Notion, Slack, and Google Drive. Only link the sources you are comfortable sharing.

Go ahead and link all platforms you’re comfortable connecting.

Go ahead and link the platforms that make sense for your workflow. If you mainly want Unabyss to understand your public profile and writing style, connecting LinkedIn and X may already be useful.

If you want it to understand your development work, GitHub will obviously matter more. If you want it to help with meetings, planning, or work history, tools like Gmail, Calendar, Drive, and Notion become more useful.

For the GitHub connection, you need to manually choose the repositories that will be imported into the context.

I won’t recommend syncing everything because it’ll bloat the context and slow down the syncing. Just choose the one you think needs to be synced.

For files not on cloud services, such as PDFs, notes, or local documents, you can upload them directly into the Sources dashboard. Unabyss processes these files to integrate their information into your overall context.

If there is a file that’s not on your Google Drive or it’s a favorite book that you have in PDF or whatever format, you can just upload it in here and it’s going to be funneled into your context as well.

What happens underneath is that Unabyss structures and organizes all the information about you. It connects facts, pulls useful details from your sources, and builds a fuller context of your identity, work, projects, and preferences.

Now let’s try the chatbot to see if it’s able to extract data from the apps I’ve connected. Here’s a sample response when asked who am I.

Perfect! The model was able to combine information about me from both LinkedIn and X. This is a lot more accurate than ChatGPT or Gemini alone because it is not only relying on past conversations. It is pulling from a structured context created from the apps I connected.

Connecting to Claude via MCP

The easiest way to connect to Unabyss is through OAuth.

Open a terminal and execute the following command:

claude mcp add --transport http unabyss https://mcp.unabyss.com/

This will add the unabyss to your local MCPs, but notice that it requires authentication.

Hit enter and select the Authenticate option in the next screen.

This will open a browser window where you need to explicitly approve the authentication request. You can also adjust the connection name and the set of permissions in this modal window.

If all looks good, click on the Approve button and wait until you see the success message. Close the browser window and notice that an authentication success message is displayed in the terminal.

Another way to connect to Unabyss is via a bearer token. Open MCP tokens and create a long-lived bearer for the app or agent you’re connecting.

Now that you have the token, the next step is to connect it to your favorite agentic development environment. Unabyss supports some of the most popular ADEs out there, like Claude Code, Cursor, OpenClaw, Codex, ChatGPT, OpenCode, Claude, and more.

For Claude Code, there are two ways to do this.

The first option is to add the MCP through Claude. Open a terminal and run the following command:

# Add Unabyss as an HTTP MCP for Claude Code
claude mcp add --transport http unabyss https://mcp.unabyss.com/ \
  --header “Authorization: Bearer <your-mcp-token>”

This adds Unabyss as an HTTP MCP server with a bearer token header. Restart any open Claude Code sessions after running the command.

Get 20% off for 1 year

To confirm that the MCP has been successfully installed, type /mcp in your terminal, check if the /unabyss option is there.

Another way is to implement a universal mcpServers JSON configuration. Hosts that read an mcpServers config block can use this directly, which is helpful if you want to share the same setup across machines.

{
  “mcpServers”: {
    “unabyss”: {
      “url”: “https://api.unabyss.com/mcp/”,
      “headers”: {
        “Authorization”: “Bearer <your-mcp-token>”
      }
    }
  }
}

The final thing to do is add the system prompt into CLAUDE.md. Here’s the full text:

## Unabyss — User Context Layer

You have access to Unabyss, the user’s persistent context layer across AI tools. It knows their background, role, projects, preferences, prior decisions, and connected data sources.

**Session start:**
- Call `unabyss.whoami` once to load baseline context about the user (name, role, key facts) — same cost as a single `query`.
- Call `unabyss.list_integrations` to see what data sources the user has connected. If a task needs an app that isn’t connected, call `unabyss.propose_connection` instead of degrading the answer.
- Call `unabyss.export_list` to see prebuilt context exports. Any export flagged as changed since last read is worth reading via `unabyss.export_read`.

**Reading context:**
- `unabyss.query` — fast lookups. Use when you need a specific fact the user has already shared (”what’s my stack”, “what’s my role”).
- `unabyss.agentic_query` — deep reasoning. Use for synthesis (”how would I approach X”, “what would I think about Y”). If it returns a `query_id`, poll `unabyss.agentic_query_read` after the suggested delay.

**Writing context:**
- Call `unabyss.store` whenever the user states a preference, makes a decision, mentions a tool they use, names a project, or shares any durable fact. Err on the side of storing — persistence across tools is the entire point.
- When you learn significant new identity facts about the user (new role, project, location), propose an `unabyss.update_identity` change — show the proposed summary and wait for explicit confirmation before calling. Never write the identity summary without asking first.

**Exports:**
- `unabyss.export_create_from_text` — instant and free. Use when the user asks to save a response, summary, or analysis as an export.
- `unabyss.export_create` and `unabyss.export_refresh` are expensive multi-minute generations. Only call when the user explicitly asks for a new or refreshed export.

Treat Unabyss as the source of truth for personal context. Your session memory is not.

This tells Claude Code when to query Unabyss, when to store new memories, and when to skip expensive exports.

You can drop the file at the project root for per-repo behavior, or in ~/.claude/CLAUDE.md for global use. I personally like the global setup if you want Claude Code to always know that Unabyss exists. For project-specific behavior, the repo-level file makes more sense because you can write instructions that only apply to that codebase.

I understand if you have security concerns about handing over your data to an external entity. This is why Unabyss gives you the option to hide your private info and confidential company data.

You can also hide data from specific apps like Gmail or Slack if you are not comfortable sharing private conversations with the LLM.

Awesome. Now that all the permissions and the CLAUDE.md file have been updated, let’s check if Claude Code can trigger the MCP when asked specific questions about me.

This is a good starting test because it checks if Claude Code can pull my general context from Unabyss. I wanted to see if it could understand my identity, my role, the tools I use, and the projects connected to my profile without me manually explaining everything again.

The initial response was great because it pulled together details from the sources I connected. Instead of giving a vague answer based only on the current chat, Claude Code had access to a broader context layer.

Then I asked a more specific follow-up:

As you can see in my terminal logs above, Unabyss was able to pull context from GitHub and make it available inside Claude Code. That means I did not have to go through the usual hoops of making the agent inspect the repository from scratch, read multiple files, guess what the project is about, and slowly build its own understanding of the codebase.

That process usually burns a lot of tokens before the actual work starts. This saves time, saves tokens, and makes the coding agent feel less blind at the beginning of a task.

I am actually smiling while using this tool because I can already imagine the dev benefits and cost savings this’ll give me when I scale my projects.

Why Should You Care?

Shared context is important because most AI workflows now happen across multiple tools, and each tool usually starts with its own isolated context.

That means you spend time copying and pasting the same information everywhere. You explain your company. You explain your product. You explain your writing style. You explain what the AI should avoid doing.

Having a shared context across all your AI tools is a huge lifesaver.

1. Time savings: This eliminates the repetitive work of re-explaining context across agents

2. Token efficiency: It reduces wasted tokens, especially for large development projects

3. Consistency: You can maintain uniformity across agents in tone, style, and project understanding

4. Accuracy: This minimizes mistakes caused by stale or conflicting information

I also think this product can evolve in very interesting ways. One obvious direction is tighter integration with agent loops, especially workflows inspired by Karpathy’s loop. If Unabyss becomes the shared context layer behind that process, the agent does not only operate from the current session. It can work with a more complete memory of your projects, preferences, and previous decisions.

Another interesting direction is local support. I know not everyone is comfortable connecting cloud apps or letting external tools process sensitive data. A local-first version or hybrid setup would be really useful for developers, researchers, lawyers, consultants, and companies that work with private documents.

There is also a strong Obsidian-style angle here. A lot of people already treat Obsidian as their second brain. The problem is that most AI tools still cannot reliably use that knowledge across different environments. If Unabyss can integrate deeply with that kind of personal knowledge loop, it could become a bridge between human notes and AI agents.

These are just some of my ideas. I am looking forward to seeing what the engineers have under their sleeves and how the product evolves in the next couple of months.

Get 20% off for 1 year

Final Thoughts

The main idea I wanted to explore in this article is shared context for LLMs and AI agents. We already have powerful models. We already have impressive coding agents. But the context layer is still messy for most people.

That is why I like what Unabyss is trying to pull off. I have been waiting for a solution like this because most of the coding agents I use, especially the ones powered by Claude Code, depend heavily on context. If the context is weak, the output becomes weak too. You see, if the context is scattered, the workflow becomes slow and expensive.

This is a huge deal if you are doing agentic coding, jumping between several AI tools every day. Instead of rebuilding your context from scratch in every app, Unabyss gives you one shared layer that your agents can pull from. It does not replace Claude Code, Cursor, and Codex. It makes them easier to use together.

Of course, this is still the initial version, so there is a lot of room for improvement. I would love to see deeper integrations, stronger local support, better controls for different agent types, and more workflows around developer tools.

Again, Unabyss was just launched today on Product Hunt. Check out the launch here and give them some love!

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

Today, I opened the Antigravity desktop app and saw a major update notification. I thought it was just a normal update at first, but it turns out Google changed the whole app experience.

Subscribe now

According to Google, the new app has been rebuilt from the ground up to deliver an agent-optimized experience.

I actually watched the Google I/O 2026 keynote to see what was new in the app before updating to the latest version. The demos were pretty impressive, especially when they showed an example where over 90 agents worked together to build a working OS in 12 hours while consuming less than $1,000 worth of tokens.

This is exactly what I needed to supercharge my development workflow.

I mean, I was super impressed with what they showed today, but I was also concerned after seeing the UI and UX changes during the demos.

I jumped right into my own Antigravity desktop app and updated to the new version. In case you are wondering, this is what the update screen looks like:

The new standalone app allows you to orchestrate multiple agents to execute tasks in parallel. It also features dynamic subagents for parallelized workflows, scheduled tasks for background automation, and ecosystem integrations across Google AI Studio, Android, and Firebase.

These are the main features:

1. An Abstracted UI: Your AI agents’ central command center, providing a unified platform to launch, monitor, and orchestrate their activities.

2. Dynamic Subagents: Subagents are defined and instantiated dynamically to tackle parallel parts of complex problems, leading to faster and better results.

3. Scheduled Tasks: Automate routine checks with Scheduled Tasks. Simply define a cron schedule, and the agents start and run autonomously in the background.

4. Artifacts: Deliverables from the agent that communicate its progress with you.

5. Extended Customization: Create or download fully customizable skills to further your agent’s autonomy and transform how you get work done.

There is also a support for Gemini audio models that lets you speak your prompts and the ability to define global or workspace-specific Skills, MCPs and JSON Hooks to encourage custom agent behavior.

The problem is that the actual update felt confusing the moment I started using it. This is what the Antigravity 2.0 dashboard looks like on my screen:

You see, I already loaded a project and ran a prompt with Gemini 3.5 Flash.

First impression: much of the UI components were trimmed down.

And I do not mean “cleaner” in a good way. I mean things I expected to be there were all gone.

1. Where’s the project explorer?

2. How to open the file editor?

3. How do I launch a new terminal window?

4. Where do I monitor the token consumption?

5. How do I trigger subagents?

These are the first things a developer looks for when opening an IDE.

I have no idea what the Google engineers were thinking, but this new UI and UX is not what I was expecting. I can no longer bring up a terminal with the usual Ctrl + Shift + ~ shortcut. The current project is not even listed in the projects list despite just being recently added.

So now, I am forced to execute terminal commands inside the prompt field. This counts toward my token consumption, and it is so slow!

Read more

As a developer who has been building software products for the past five years, getting online visibility is just as challenging as building the product itself.

Subscribe now

When promoting my apps online, I basically have two options:

1. One is paid promotions. You can run ads, sponsor newsletters, pay writers, or buy placements. This can work, but it gets expensive fast…

Read more

I am not a marketing expert, and I do not own a large brand with a full creative team behind it. But I can tell when a marketing asset works. It makes you stop, understand the product, and feel something about the brand. That is harder to create than it looks.

Subscribe now

That is where AI is becoming useful. Brands can now test campaign ideas, product shots, ad layo…

Read more

I use GitHub almost every day.

For personal projects, client work, experiments, and pretty much anything that involves code, GitHub is always part of my workflow. I push code, create branches, connect repos to deployment tools, and store a lot of my projects there without thinking too much about the system behind it.

Subscribe now

So when I saw a post on X about a vuln…

Read more

For the past few years, I’ve been experimenting with how software gets built when you have coding agents doing the heavy lifting.

Subscribe now

I come from a developer background, and like most people who build software products for a living, I’ve watched the tooling change fast. What started as autocomplete and code suggestions has become something much more capable:…

Read more

Hey guys, it has been a week since I launched BloggFast.

For those who are new here, BloggFast is a Next.js blog boilerplate that gives you a fully wired, production-ready AI-powered blog site out of the box. Instead of spending weeks integrating authentication, database, CMS, email, hosting, and AI services, you get all of that configured and connected …

Read more

If you want to launch your own blog or news website with full control over the source code, I built BloggFast for you. It is a full-stack NextJS boilerplate built to help you move faster without having to piece everything together from scratch.

Subscribe now

Instead of spending days setting up authentication, the database, CMS, email, hosting, and AI article generatio…

Read more

I was at a coffee shop this afternoon when I saw a group of students doing some school activities. One of them was using ChatGPT to create presentation slides. The thing is, ChatGPT cannot really spit out a complete PPT file in one shot in the way many people expect. In many cases, it gives you content, structure, and instructions on how to build each s…

Read more

Back in 2024, I had the idea of building my own blog site from scratch.

It is not that I do not enjoy platforms like Medium or Substack. I actually like using them. But at the end of the day, I still do not have full control over the website. I cannot fully customize the UI or UX the way I want, and I am limited by the platform’s system and design decisi…

Read more

NVIDIA announced NemoClaw at GTC 2026 less than a week ago. It’s a security wrapper for OpenClaw, the open source AI agent platform that became the fastest growing open-source project in history, but got plagued with security concerns. Kernel-level sandboxing, a deny-by-default policy engine, and a privacy router.

One group of researchers called it a “lethal trifecta.”

Subscribe now

NemoClaw is NVIDIA’s response. It wraps OpenClaw inside the OpenShell runtime with three layers of protection:

• A kernel-level sandbox using Landlock, seccomp, and network namespaces

• An out-of-process policy engine that agents supposedly cannot override

• A privacy router that keeps sensitive data on local Nemotron models while routing complex queries to cloud APIs

Zack Korman, a cybersecurity professional and CTO at Pistachio, started poking at Nemoclaw. Korman’s background is in threat detection, and he has a law degree from Edinburgh and a master’s from Oxford, so he knows how to read documentation carefully.

The Vulnerability Korman Found

Read more

OpenAI’s pre-IPO investor document landed this week, and the most interesting part isn’t the $830 billion valuation target or the Q4 2026 IPO timeline. It’s the section where OpenAI tells prospective investors, in writing, that Microsoft is a risk to their business.

The filing reads:

“If Microsoft modifies or terminates its commercial partnership with us, or if we are unable to successfully diversify our business partners, our business, prospects, operating results and financial condition could be adversely affected.”

That’s the company that gave OpenAI $13.8 billion, most of its compute, and its primary distribution channel being formally listed as a threat.

It’s crazy.

How We Got Here

Read more

Manus has been a cloud-first AI agent since its launch in March 2025. You give it a task, it opens a sandboxed environment, browses the web, writes code, and delivers results. But there was one big limitation—it could not touch your local machine.

Subscribe now

That changes today.

Manus released My Computer, the core feature of a new Desktop app that gives the agent direct access to your files, terminal, applications, and hardware. It is available now on macOS and Windows.

This is the first major product release since Meta acquired Manus for roughly $2 billion in late 2025.

What Is My Computer?

My Computer is a feature inside the new Manus Desktop app. It extends Manus from a cloud-only agent into one that can operate directly on your local machine.

Read more

After weeks of rumors, Jensen Huang finally revealed NemoClaw during NVIDIA GTC 2026 as a security focused layer for the OpenClaw ecosystem. The goal is to autonomous agents safer to run without limiting what they can do.

Subscribe now

OpenClaw went viral in a matter of weeks and that momentum also exposed a bunch of security concerns. Agents often run with broad permissions, which makes data access and execution harder to control in practice.

NVIDIA’s answer is NemoClaw.

What is NemoClaw?

It is a runtime layer that sits on top of OpenClaw and enforces how agents behave. It does not replace OpenClaw. It constrains it.

You still get autonomous agents, but they run inside a controlled environment with explicit rules for data access, network calls, and execution.

NVIDIA implements this using OpenShell, which acts as the secure execution layer. Every agent runs inside a sandbox, and every action passes through policy checks. That includes file access, outbound requests, and model inference.

Here’s what the NemoClaw workflow looks like:

Read more

OpenClaw went from zero to 314,000 GitHub stars in under four months. It surpassed React. It surpassed Linux. It became the most-starred non-aggregator software project on GitHub, period.

Subscribe now

But OpenClaw is no longer alone.

In the eight weeks since it exploded, the “Claw” ecosystem has spawned at least nine serious open-source AI agent projects, each attacking a different slice of the problem. Rust rewrites. Go ports for $10 hardware. Container-isolated forks built specifically to fix OpenClaw’s security nightmares.

Now there’s a live scoreboard tracking the whole thing. ClawCharts is a free, real-time analytics dashboard that ranks every major Claw project by star growth, contributor activity, and commit velocity.

What Is ClawCharts?

ClawCharts pulls live data from the GitHub API and ranks projects using a composite momentum score. The primary drivers are seven-day stars gained (plus percentage change), seven-day contributors (plus percentage change), and seven-day commits (plus percentage change). Total stars serve as a tiebreaker.

This is what the dashboard looks like:

Read more

Paul Conyngham didn’t go to medical school. He runs a machine learning consultancy in Sydney, spends most of his time with data pipelines and prediction models, and has no formal background in biology or oncology. But when his rescue dog Rosie was diagnosed with aggressive mast cell cancer in 2024 and given only months to live, he did something that most researchers would have called impossible for a non-specialist: he used AI to design her a custom cancer vaccine.

Subscribe now

The tumor on Rosie’s back leg shrank by more than 50% within one month of her first injection. She is alive and, by all accounts, chasing rabbits again.

I’ve been covering generative AI for a while now, and I’ve watched it get applied to code generation, legal documents, financial modeling, and drug discovery at the institutional level. But this story cuts differently. It’s a single person, working mostly alone, who took tools that were publicly available and used them to do something that had never been done before for a dog. The implications for human medicine are hard to overstate.

The Dog Who Started It All

Rosie is a Staffordshire Bull Terrier and Shar Pei cross. Conyngham adopted her from a Sydney shelter in 2019, after she had been abandoned in bushland. He describes her as his closest companion through some of the hardest stretches of his life.

In 2024, large tumors appeared on one of her back legs. The diagnosis was mast cell cancer, the most common skin cancer in dogs and notoriously difficult to treat once it spreads beyond the initial site. Conyngham spent thousands of dollars on veterinary chemotherapy and surgical intervention. The treatments slowed the cancer. They did not shrink the tumors.

He started thinking about a different approach.

How ChatGPT Became a Biomedical Research Partner

Read more

There’s a reason OpenClaw became one of the fastest-growing open-source projects in history. Within 60 days of its January 2026 release, it gained over 250,000 GitHub stars, outpacing the growth of major projects like React and even Linux in a fraction of the time.

Subscribe now

People became excited because this AI companion runs locally on your computer. It can acce…

Read more

Google’s AI-powered marketing tool Pomelli just expanded its availability to over 170 countries and territories, making it accessible to a much wider audience of businesses and creators.

Subscribe now

Pomelli is an experimental AI-powered marketing tool from Google Labs, developed in collaboration with DeepMind. It’s designed to help small-to-medium-sized businesses (SMBs) automatically generate on-brand social media campaigns, ads, and marketing visuals with minimal effort.

Instead of manually building brand kits or designing campaigns from scratch, Pomelli simply asks for a website URL. It then scans the site and constructs what Google calls a “Business DNA”. From there, the AI generates customized, editable marketing materials that stay consistent with your brand.

Key Features

• Automatic Brand Analysis: Pomelli scans your website and automatically identifies your logos, fonts, color schemes, imagery, and tone of voice.

• On-Brand Content Generation: Using the extracted brand information, the tool generates social media posts, ads, and campaign ideas tailored specifically to your brand style.

• AI Image Enhancement: It can turn basic product photos into studio-quality marketing visuals, complete with AI-generated backgrounds and lighting.

• Editable Assets: All generated content remains fully editable, allowing you to tweak text, colors, and visuals before exporting.

• Free Experimental Access: Currently, Pomelli is available as a free experimental tool through Google Labs, though it was previously limited to users in the United States.

Creating Marketing Assets with Pomelli

Head over to Google Labs and look for the Pomelli tool. Take note that you need to be logged in with your Google account to be able to use it.

Read more

You can now use ChatGPT to build, update, and analyze spreadsheets faster in MSFT Excel. It’s an Excel add-in that brings ChatGPT directly into workbooks, helping users run scenarios and generate outputs based on cells and formulas.

Subscribe now

Here’s how it works:

1. Build and update spreadsheet models faster: Describe what you need in plain language and ChatGPT will create or update live Excel models while preserving formulas, structure, and assumptions.

2. Get insights from large spreadsheets: ChatGPT analyzes how sheets and formulas connect, explains changes in results, and traces or fixes errors in complex workbooks.

3. Follow the logic and trust the outputs: ChatGPT links answers to the exact cells it uses and asks permission before making edits, so teams can audit formulas and verify results.

The tool is powered by GPT-5.4 and can be installed from the Add-in tab in the web version of MSFT Excel.

Read more