Last Updated: 23 May 2026

Perplexity has released Bumblebee, an open source security scanner made for developer machines. It looks for risky packages, browser extensions, editor extensions, and AI tool configs on macOS and Linux devices. The tool was first used inside Perplexity and is now public on GitHub.
When a risky package appears, security teams do not want a long guessing session. They want to know which developer laptops may have the risky version right now. Bumblebee is built to answer that question by reading local metadata from files that already exist on the machine.
Bumblebee is a read only inventory tool for developer endpoints. It checks what is already present on a developer machine and turns that local information into structured records. It focuses on software supply chain risk, which means problems caused by bad packages, bad extensions, or risky developer tool settings.
The tool supports macOS and Linux. It is written in Go, needs Go 1.25 or later, and has no non standard library dependencies. Its first tagged release is v0.1.1, and the project is licensed under Apache 2.0.
Perplexity says Bumblebee is meant to answer one narrow question: when an advisory names a package, extension, or version, which developer machines show a match in local metadata right now? That focus keeps the tool clear. It is not trying to replace every security product.
Developers often install many tools on their own machines. A single laptop can include JavaScript packages, Python packages, Go modules, editor plugins, browser extensions, and AI agent settings. That mix is useful for work, but it also creates many places where a risky dependency can hide.
Traditional tools can miss part of that picture. SBOM tools help teams understand what shipped in software. EDR tools help teams see what ran or touched the network. Bumblebee looks at another layer: the local files and metadata sitting across a developer’s machine.
That is useful during a software supply chain incident. When a bad version is named, a team can scan developer devices and compare the results with its own exposure catalog. Bumblebee can then flag exact matches and show the evidence behind them.
It helps teams move from panic to a clear list of affected machines. Making things much easier for dev teams.
Bumblebee covers several areas that are common on developer machines. It reads package metadata, lockfiles, extension manifests, and supported MCP JSON configuration files. It does not need to run the tools it checks.
The scanner covers:
For AI users, the MCP part is one of the most interesting details. MCP configs can connect AI tools to outside services. Bumblebee reads supported JSON configs to build a server inventory, but it does not emit environment values from env blocks. That means it can check for risk without printing secrets into its output.
The current version does have limits. For example, Bun’s binary lockfile format is not parsed in v0.1, and non JSON MCP configs are also not parsed in that version.
Bumblebee is built as a one time scanner. Each run checks the machine once, creates its results, and then closes. It does not stay active in the background or keep watching the device. This makes it easier for security teams to control when scans happen and how often they run.
Teams can schedule Bumblebee in the way that fits their workflow. They can run it with tools like cron, launchd, systemd, or fleet management software. For example, a company could scan developer machines once a day, once a week, or only during a supply chain incident. That gives teams flexibility without adding another always on agent.
Bumblebee saves its results in NDJSON, a format where every line works as its own JSON entry. This makes the data easier to send into security tools, dashboards, logs, or internal systems. Each package entry can show the machine name, operating system, package name, version, source file, and confidence level. For security teams, that means the scan does more than list possible risks. It also shows where each finding came from and how reliable it may be.
The confidence field adds important context. Not every local clue has the same value. A high confidence result means the package identity and version came from trusted metadata. A medium or low confidence result means the team should review it more carefully before taking action. This helps reduce noise and makes the scan results easier to trust.
The read only design is the center of Bumblebee. It does not run npm, pip, Go commands, or other package managers. It does not read source files. It does not watch processes or monitor network activity.
That choice matters because some malicious packages can run code during install steps. A scanner that calls a package manager could trigger the very behavior a team wants to avoid. Bumblebee takes a safer path by reading existing files instead.
The tool has three scan profiles. Baseline checks common global and user package roots, toolchains, extensions, browser extensions, and MCP configs. Project checks selected development folders. Deep scans paths chosen by the operator, often during an active incident.
Bumblebee is mainly useful for security engineers, DevSecOps teams, and companies with many developers using many tools. It gives them a faster way to check local exposure after a known risk appears. It also gives them a format that can be used with their own catalogs of bad versions and configurations.
The tool also fits Perplexity’s wider focus on AI agents and enterprise use. Perplexity has said Bumblebee can connect with Computer so deeper scans can be triggered when a new software supply chain risk appears. That link shows how security checks may become part of AI driven work systems.
For regular AI followers, the main point is easy to understand. As AI tools become more connected to browsers, editors, code projects, and company systems, local developer environments become more important. Bumblebee is a practical attempt to make those environments easier to inspect.
Perplexity Bumblebee is not a flashy consumer AI feature. It is a practical security tool for teams that need to know where risk exists across developer machines. It scans local metadata, checks known risky packages and extensions, and gives security teams structured output they can act on.
As AI tools connect to more developer systems, security needs to move closer to the actual places where developers work. Bumblebee is one step in that direction: simple, open source, read only, and focused on a real problem.
Perplexity Bumblebee is an open source security scanner for developer machines. It works on macOS and Linux and checks local files for risky packages, extensions, and AI tool configs. It does not scan in the same way as a full endpoint security platform. Its job is narrower. It helps teams answer whether a known risky package, extension, or version appears on a developer device. This makes it useful during software supply chain incidents where speed and evidence are important.
Bumblebee is built as a read only scanner, so it does not change the machine during a scan. It does not run package managers, install packages, execute install scripts, read source files, or monitor network activity. It reads local metadata such as lockfiles, package records, extension manifests, and supported MCP JSON configs. That design lowers risk during checks because the scanner avoids actions that could trigger malicious package behavior. Teams still need to test it before using it widely.
Bumblebee scans several common parts of a developer environment. It can read metadata from npm, pnpm, Yarn, Bun, PyPI, Go modules, RubyGems, and Composer. It also checks editor extensions for tools such as VS Code, Cursor, Windsurf, and VSCodium. For browsers, it covers Chromium family browsers and Firefox. It also reads supported MCP JSON host configuration files. The goal is to collect useful local evidence across tools that developers often use every day.
Bumblebee is mainly for security engineers, DevSecOps teams, incident response teams, and companies with many developers. It is most useful when a team already knows what risky package, extension, or version it wants to find. For example, after a public warning about a bad package, the team can run Bumblebee and compare the results with an exposure catalog. Smaller teams can also use it, but they need enough security knowledge to read and act on the output.
Bumblebee does not replace SBOM or EDR tools. It fills a different gap. SBOM tools help explain what shipped inside software. EDR tools help show what ran or touched the network. Bumblebee checks local developer state, including lockfiles, package metadata, extension manifests, and supported AI tool configs. That makes it useful for fast exposure checks on developer machines. A strong security setup can use Bumblebee together with other tools, rather than treating it as a full replacement.