Skip to content
Back to search

beevibe

MarketplaceWorks with Claude CodeGitHub

Beevibe Claude Code plugins for sharing, researching, and coordinating AI agent work.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/beevibe-ai/beevibe with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/beevibe-ai/beevibe'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/beevibe-ai--beevibe/badge.svg)](/listings/beevibe-ai--beevibe)

HTML

<a href="/listings/beevibe-ai--beevibe"><img src="/api/listings/beevibe-ai--beevibe/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Two paths — pick whichever matches what you're trying to do.

One-click deploy (Railway)

Spins up Postgres + api + scheduler + web on Railway. Each user still installs `beevibe-daemon` on their own machine to actually run agent CLI sessions; the hosted api doesn't spawn local CLIs.

After the template finishes provisioning, set `ANTHROPIC_API_KEY` + `OPENAI_API_KEY` on the api and scheduler services, then point `BEEVIBE_CORS_ORIGINS` (api) and `NEXT_PUBLIC_BV_API_URL` (web build arg) at the public URLs Railway assigned. Full notes in [DEPLOYMENT.md](./DEPLOYMENT.md).

Local Docker

Brings up the whole stack — Postgres + api + scheduler + web — in containers from the repo root. No Node, no pnpm, no migrations to run by hand.

git clone https://github.com/beevibe-ai/beevibe.git && cd beevibe

ANTHROPIC_API_KEY=sk-ant-… \
OPENAI_API_KEY=sk-…       \
docker compose -f docker-compose.quickstart.yml up -d --build

Then open <http://localhost:3030>.

The compose file builds the three Node images from `infra/railway/`, runs migrations as a one-shot, and starts the stack. To shut it down:

docker compose -f docker-compose.quickstart.yml down -v

To actually dispatch agent work after the stack is up, install the daemon on the machine where Claude Code lives and point it at the api:

brew install beevibe-ai/tap/beevibe-daemon
beevibe-daemon setup --api http://localhost:3000 --user-token <bv_u_…>
beevibe-daemon start

The `bv_u_` token is created by `pnpm provision-user` (see [CONTRIBUTING.md](./CONTRIBUTING.md#minting-a-bv_u_-token-for-the-daemon)).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 27 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
  3. "name": "beevibe",
  4. "description": "Beevibe Claude Code plugins for sharing, researching, and coordinating AI agent work.",
  5. "owner": {
  6. "name": "Beevibe",
  7. "email": "hello@beevibe.ai",
  8. "url": "https://github.com/beevibe-ai"
  9. },
  10. "plugins": [
  11. {
  12. "name": "adr",
  13. "description": "Architecture Deep Research - scan a repo, draft a PRD, run live deep research, and get a cited handoff for system-design decisions.",
  14. "author": {
  15. "name": "Beevibe"
  16. },
  17. "category": "agent-orchestration",
  18. "source": {
  19. "source": "git-subdir",
  20. "url": "https://github.com/beevibe-ai/architecture-deep-research.git",
  21. "path": "plugin",
  22. "ref": "main"
  23. },
  24. "homepage": "https://github.com/beevibe-ai/architecture-deep-research"
  25. }
  26. ]
  27. }
README.md · README · 193 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. # Beevibe
  3. ### The agent-native operating system for companies.
  4. [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](./LICENSE)
  5. [![GitHub stars](https://img.shields.io/github/stars/beevibe-ai/beevibe?style=social)](https://github.com/beevibe-ai/beevibe)
  6. [Architecture](#architecture) · [Concepts](#core-concepts) · [Quick Start](#quick-start) · [Deploy](./DEPLOYMENT.md) · [Contributing](./CONTRIBUTING.md)
  7. </div>
  8. ---
  9. ## What is Beevibe?
  10. Beevibe is a shared workspace where a team's people and AI agents work side
  11. by side. Agents hold lasting roles, build bounded domain memory, ask the
  12. right teammate when their context runs out, and escalate blockers back to
  13. humans.
  14. It's the missing layer between your AI tools and your team. Slack, Notion,
  15. and Linear are how humans coordinate. Beevibe is the same surface for the
  16. AI side of the team — so the same context isn't re-explained dozens of
  17. times a week and the same answer isn't learned and forgotten across
  18. different engineers.
  19. Beevibe is **self-hosted**. You own the Postgres database, the Node
  20. services, the local daemon processes, and the CLI binaries doing the work.
  21. ## Why Beevibe?
  22. Every engineer now works with AI all day: Claude Code, Cursor, Codex, and
  23. whatever comes next. Individually, they're faster than ever. Then the team
  24. gets in a room together and coordination is still stuck at 2019 speed.
  25. The problem isn't that the agents are too weak. The problem is that each
  26. person's AI work lives in a private bubble, and no shared intelligence
  27. compounds.
  28. - **Shared AI workspace.** People and agents work in the same team graph
  29. with tasks, ownership, review, handoffs, and escalation.
  30. - **Persistent specialists.** Each agent has an identity, domain, hierarchy
  31. level, and bounded memory that deepens across sessions.
  32. - **Agent-to-agent coordination.** When an agent leaves its domain, it can
  33. ask another specialist for context or negotiate toward a solution.
  34. - **Human-in-the-loop control.** Humans review, redirect, revise, cancel,
  35. and resolve blockers from the dashboard.
  36. - **BYO CLI.** Each user runs their own Claude Code (or other) CLI on their
  37. own machine via a local daemon — your tools, your files, your tokens.
  38. ## Architecture
  39. ```text
  40. Humans Agents
  41. ────── ──────
  42. ┌──────────────────────────┐ ┌──────────────────────────┐
  43. │ Web dashboard │ │ Claude Code CLI │
  44. │ (Next.js) │ │ (one per agent run) │
  45. └────────────┬─────────────┘ └────────────┬─────────────┘
  46. │ REST + SSE │ MCP tools
  47. │ │ (HTTPS)
  48. ▼ ▼
  49. ┌─────────────────────────────────────────────────┐
  50. │ @beevibe/api │
  51. │ control plane: REST · SSE · MCP · /runtime · WSS │
  52. └─────────┬─────────────────────────┬─────────────┘
  53. │ │
  54. │ SQL │ WS push +
  55. │ │ HTTP claim
  56. ▼ ▼
  57. ┌──────────────────────┐ ┌─────────────────────┐
  58. │ Postgres + pgvector │ │ beevibe-daemon │
  59. │ shared state, mesh, │ │ (your laptop) │
  60. │ memory, sessions │ │ │
  61. └──────────┬───────────┘ │ spawns the local │
  62. │ poll for │ Claude CLI for │
  63. │ fallback claim │ every session │
  64. ▼ │ pinned to this │
  65. ┌──────────────────────┐ │ machine │
  66. │ @beevibe/scheduler │ └─────────────────────┘
  67. │ server-side spawn │
  68. │ (offline daemons) │
  69. │ + orphan reaping │
  70. └──────────────────────┘
  71. ```
  72. The **api** is the control plane. **Postgres** is the shared coordination
  73. and memory layer. **Local daemons** run the actual CLI sessions where each
  74. user's tools and files live. The **scheduler** is a server-side fallback
  75. for mesh asks targeting agents whose daemon is offline, plus the orphan
  76. reaper for crashed sessions.
  77. For a deeper version of any layer, see the package READMEs:
  78. - [packages/api](./packages/api/README.md) — MCP tools, REST, SSE, MeshServer, daemon control plane
  79. - [packages/core](./packages/core/README.md) — domain types, ports, services, adapters
  80. - [packages/daemon](./packages/daemon/README.md) — local CLI claimer + spawner
  81. - [packages/scheduler](./packages/scheduler/README.md) — server-side fallback claimant
  82. - [packages/web](./packages/web/README.md) — Next.js dashboard
  83. ## Core Concepts
  84. | Concept | Meaning |
  85. | --- | --- |
  86. | **Workspace** | The company-level place where people, agents, tasks, memory, and review live together. |
  87. | **Agent** | A persistent domain expert with a role, hierarchy level, memory, API key, and preferred runtime. |
  88. | **Task** | A unit of team work assigned to a person or agent. Tasks can spawn child tasks and move through review. |
  89. | **Mesh** | The agent-to-agent layer for asking the right teammate, negotiating, responding, and escalating. |
  90. | **Memory** | Durable per-agent core memory blocks plus vector-searchable facts that compound across team work. |
  91. | **Runtime** | A registered `(daemon, CLI)` pair, such as a user's local `claude`, `codex`, or `opencode` binary. |
  92. | **Daemon** | A local process that claims sessions and spawns CLI runs on a user's machine. |
  93. ## Quick Start
  94. Two paths — pick whichever matches what you're trying to do.
  95. ### One-click deploy (Railway)
  96. Spins up Postgres + api + scheduler + web on Railway. Each user still
  97. installs `beevibe-daemon` on their own machine to actually run agent CLI
  98. sessions; the hosted api doesn't spawn local CLIs.
  99. [![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/beevibe)
  100. After the template finishes provisioning, set `ANTHROPIC_API_KEY` +
  101. `OPENAI_API_KEY` on the api and scheduler services, then point
  102. `BEEVIBE_CORS_ORIGINS` (api) and `NEXT_PUBLIC_BV_API_URL` (web build arg)
  103. at the public URLs Railway assigned. Full notes in
  104. [DEPLOYMENT.md](./DEPLOYMENT.md).
  105. ### Local Docker
  106. Brings up the whole stack — Postgres + api + scheduler + web — in
  107. containers from the repo root. No Node, no pnpm, no migrations to run by
  108. hand.
  109. ```bash
  110. git clone https://github.com/beevibe-ai/beevibe.git && cd beevibe
  111. ANTHROPIC_API_KEY=sk-ant-… \
  112. OPENAI_API_KEY=sk-… \
  113. docker compose -f docker-compose.quickstart.yml up -d --build
  114. ```
  115. Then open <http://localhost:3030>.
  116. The compose file builds the three Node images from `infra/railway/`, runs
  117. migrations as a one-shot, and starts the stack. To shut it down:
  118. ```bash
  119. docker compose -f docker-compose.quickstart.yml down -v
  120. ```
  121. To actually dispatch agent work after the stack is up, install the daemon
  122. on the machine where Claude Code lives and point it at the api:
  123. ```bash
  124. brew install beevibe-ai/tap/beevibe-daemon
  125. beevibe-daemon setup --api http://localhost:3000 --user-token <bv_u_…>
  126. beevibe-daemon start
  127. ```
  128. The `bv_u_` token is created by `pnpm provision-user` (see
  129. [CONTRIBUTING.md](./CONTRIBUTING.md#minting-a-bv_u_-token-for-the-daemon)).
  130. ## Contributing
  131. Issues and PRs are welcome. For larger changes, open an issue first so the
  132. direction is clear before implementation. See
  133. [CONTRIBUTING.md](./CONTRIBUTING.md) for local development setup, the DCO
  134. sign-off requirement, and the contribution license terms.
  135. ## License
  136. The Beevibe source code is licensed under the
  137. [Apache License 2.0](./LICENSE).
  138. The Beevibe name and logo are project trademarks. Apache 2.0 grants rights
  139. to the source code; it does not grant rights to use the project's name or
  140. marks. Forks and derivative works are welcome under names that are not
  141. "Beevibe."
  142. ## Star History
  143. <a href="https://www.star-history.com/?repos=beevibe-ai%2Fbeevibe&type=date&legend=bottom-right">
  144. <picture>
  145. <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=beevibe-ai/beevibe&type=date&theme=dark&legend=top-left" />
  146. <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=beevibe-ai/beevibe&type=date&legend=top-left" />
  147. <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=beevibe-ai/beevibe&type=date&legend=top-left" />
  148. </picture>
  149. </a>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.