Skip to content
Back to search

Hexis

Centrally manage AI-agent skills, tools, context, permissions, and identity across your entire org. Self-hosted, Git-backed and MCP-native.

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/Bevel-Software/Hexis 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/Bevel-Software/Hexis'

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/bevel-software--hexis/badge.svg)](/listings/bevel-software--hexis)

HTML

<a href="/listings/bevel-software--hexis"><img src="/api/listings/bevel-software--hexis/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

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.

README.md · README · 390 lines

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

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center">
  2. <img src="docs/hero-light.svg" alt="Hexis by Bevel: git-backed skills, tools and context for AI agents" width="100%">
  3. </p>
  4. <p align="center">
  5. <a href="https://github.com/Bevel-Software/Hexis/stargazers"><img src="https://img.shields.io/github/stars/Bevel-Software/Hexis?style=flat-square&logo=github" alt="GitHub stars"></a>
  6. <a href="https://demo.bevel.software/workspace/main/knowledge-base/KnowledgeBase/Start%20here.md"><img src="https://img.shields.io/badge/live%20demo-try%20it%20now-1b76d0?style=flat-square" alt="Live demo"></a>
  7. <a href="LICENSE"><img src="https://img.shields.io/github/license/Bevel-Software/Hexis?style=flat-square" alt="Apache-2.0 license"></a>
  8. <a href="https://github.com/Bevel-Software/Hexis/commits"><img src="https://img.shields.io/github/last-commit/Bevel-Software/Hexis?style=flat-square" alt="Last commit"></a>
  9. </p>
  10. **Git-backed control plane for AI-agent skills, tools, context, permissions and
  11. identity. Self-hosted and MCP-native.**
  12. One place where your company's AI plugins, tools and knowledge live: centrally
  13. managed, reviewed and access-controlled, and usable from **any AI agent**. The
  14. open-source core of the Bevel platform.
  15. ## Why Hexis?
  16. **Used by teams at**
  17. <p>
  18. <a href="https://osapiens.com">
  19. <picture>
  20. <source media="(prefers-color-scheme: dark)" srcset="docs/logos/osapiens-dark.svg">
  21. <img src="docs/logos/osapiens-light.svg" alt="osapiens" width="160" height="56">
  22. </picture>
  23. </a>
  24. <a href="https://beo.energy">
  25. <picture>
  26. <source media="(prefers-color-scheme: dark)" srcset="docs/logos/beo-dark.svg">
  27. <img src="docs/logos/beo-light.svg" alt="BEO" width="160" height="56">
  28. </picture>
  29. </a>
  30. <a href="https://unite.eu">
  31. <img src="docs/logos/unite.png" alt="Unite" width="160" height="56">
  32. </a>
  33. <a href="https://www.workpath.com">
  34. <picture>
  35. <source media="(prefers-color-scheme: dark)" srcset="docs/logos/workpath-dark.svg">
  36. <img src="docs/logos/workpath-light.svg" alt="Workpath" width="160" height="56">
  37. </picture>
  38. </a>
  39. </p>
  40. Read more about the learnings that we made which led to Hexis here: [Our Medium Article](https://medium.com/@ali.raza_25708/how-do-you-distribute-and-collaborate-on-agent-skills-in-enterprise-settings-bdb7097dff60)
  41. ### For teams
  42. One place where engineers and non-technical people alike can browse and load
  43. plugins, propose suggestions, and manage access.
  44. ### For enterprises
  45. Every skill, tool manual and permission is a file in a git repository you own,
  46. so the audit trail is the storage layer: who changed what, when, who approved
  47. it, and how to undo it. An agent can only do what the person running it can do,
  48. resolved per file, and it never holds the credentials it uses. Runs on your
  49. infrastructure, behind your own SSO.
  50. ### Why it's different from MCP gateways:
  51. MCP gateways are uni-directional; users can consume plugins, skills or tools but there is no mechanism here for users to propose changes or share new skills and MCP servers. You can do this via GitHub in the back, but this is not accessible to non-technical users and there is no fine-grained access control for either viewing or the review process.
  52. Hexis can do all of the above specified capabilities for distribution, and has this bidirectionality needed for management.
  53. In Hexis, skills and tool manuals are reviewable files. Anyone can propose a
  54. change; on protected branches it reaches the owners of the files it touches and
  55. ships only once they approve. Agents propose too: one that hits a broken skill
  56. mid-task can suggest the fix, and a person decides whether it lands.
  57. ## Contents
  58. - [See Hexis in action](#see-hexis-in-action)
  59. - [Connect Hexis to Cline](#connect-hexis-to-cline)
  60. - [Try the live demo](#try-it-first-the-live-demo)
  61. - [Managed hosting](#want-a-managed-instance)
  62. - [Deploy with Docker](#deploy-it-in-5-minutes-docker)
  63. - [Links and images in knowledge pages](#links-and-images-in-knowledge-pages)
  64. - [Local development](#local-development-run-from-source)
  65. - [Configuration reference](docs/configuration.md)
  66. - [Skills in Cowork and claude.ai](docs/claude-cowork.md)
  67. - [Troubleshooting](docs/troubleshooting.md)
  68. - [Repository layout](#repository-layout)
  69. - [FAQ](#faq)
  70. [![Watch the full Hexis demo](docs/demo-video-thumbnail.jpg)](https://youtu.be/RjOWRz4E0ZU?si=R7d8rT_P1YVxmQBO)
  71. *Watch the full walkthrough: connect an agent, use company context, review
  72. proposed changes, and manage team access.*
  73. ## See Hexis in action
  74. ### Propose and approve skill changes
  75. Anyone can propose a new skill or improve an existing one. On protected
  76. branches, owners review the exact change and approve it before it becomes
  77. available to the team's agents.
  78. ![A teammate proposes a skill and its owner reviews and approves the change request](docs/demo-propose.gif)
  79. ### Use your team's skills in Claude
  80. Connect Claude to Hexis over MCP, then ask normally. Claude can discover and
  81. load the approved skill instructions and company context your role can access,
  82. without copying prompts between tools.
  83. ![Claude uses approved team skills and company context through Hexis over MCP](docs/demo-claude-mcp.gif)
  84. ### Connect Hexis to Cline
  85. Cline can connect directly to Hexis as a remote Streamable HTTP MCP server.
  86. Install the public demo connection from the Cline CLI:
  87. ```sh
  88. cline mcp install hexis --transport http https://demo.bevel.software/api/mcp --yes
  89. ```
  90. Complete the OAuth sign-in in your browser when prompted. Cline then discovers
  91. the skills, tools and context your Hexis role can access. For your own Hexis
  92. deployment, replace `demo.bevel.software` with your deployment's host.
  93. ### Share skills with the right people
  94. Add teammates to roles or grant access directly when needed. Everyone connects
  95. to the same workspace, while each person and their agent only sees what they
  96. are allowed to read.
  97. ![An owner adds teammates to roles and manages access to shared company content](docs/demo-access.gif)
  98. ## Try it first: the live demo
  99. **[demo.bevel.software](https://demo.bevel.software/workspace/main/knowledge-base/KnowledgeBase/Start%20here.md)**
  100. is a public instance you can sign into with your Google account, populated
  101. with a fictional company's knowledge, skills and tools. The *Start here* page
  102. walks you through the whole loop: connect your own agent over MCP, have it
  103. build a sales deck from a skill, watch its proposed improvement arrive as a
  104. change request. The demo is shared and read-mostly (visitors propose, owners
  105. approve); everything below gets you the same thing with none of the limits.
  106. ## Want a managed instance?
  107. We run it for you (hosting, upgrades, backups, SSO) and your team just signs
  108. in. Write to **[ali.raza@bevel.software](mailto:ali.raza@bevel.software)**.
  109. ## Deploy it in 5 minutes (Docker)
  110. You need: [Docker](https://docs.docker.com/get-docker/) with Compose on a
  111. server (or your laptop; one extra line below), and an
  112. **empty git repository** on any host (GitHub, GitLab, Bitbucket, Azure DevOps,
  113. self-hosted) to hold your knowledge base. The app seeds it with a starter
  114. template on first run.
  115. Grab the two deployment files — no clone needed:
  116. ```sh
  117. mkdir hexis && cd hexis
  118. # v0.15.1 below = the release this page was written against; replace with the latest release tag
  119. wget https://raw.githubusercontent.com/Bevel-Software/Hexis/v0.15.1/docker-compose.yml
  120. wget -O .env https://raw.githubusercontent.com/Bevel-Software/Hexis/v0.15.1/.env.example
  121. ```
  122. (Working from a git clone works identically — both files sit at the repo root;
  123. `cp .env.example .env`.)
  124. Open `.env` and fill in the **four required values** (everything else can wait):
  125. ```sh
  126. ADMIN_EMAIL=you@example.com # the deployment owner, always an admin
  127. ADMIN_PASSWORD=pick-something # sign-in password; only with password login (SSO-only deployments drop it)
  128. JWT_SECRET=… # generate with the command below
  129. SECRETS_ENC_KEY=… # generate with the command below
  130. ```
  131. Generate the two secrets (run twice, paste one result into each):
  132. ```sh
  133. node -e "console.log(require('crypto').randomBytes(32).toString('base64'))"
  134. # no Node installed? docker run --rm node:22-slim node -e "console.log(require('crypto').randomBytes(32).toString('base64'))"
  135. ```
  136. For a public deployment served over HTTPS by the bundled proxy, also set the
  137. domain — it derives everything else public (origins, proxy hop):
  138. ```sh
  139. DOMAIN=bevel.your-domain.com
  140. ```
  141. Then start everything. Deploying **pulls the image CI publishes on every
  142. release** — nothing compiles on your server, so a small instance suffices.
  143. Pin the version in `.env` (`HEXIS_VERSION=0.15.1`) so a later `pull` can't
  144. become an unplanned upgrade — [UPGRADING.md](UPGRADING.md) covers upgrades
  145. and backups. Building from source instead (a staging server tracking a
  146. branch, a fork) is
  147. [deployment/docker-compose.build.yml](deployment/docker-compose.build.yml)
  148. (explained in [deployment/](deployment/README.md)).
  149. **Public HTTPS, no proxy of your own** (a bare EC2 instance, a plain VPS):
  150. the `https` profile starts Caddy in front of the app, with automatic Let's
  151. Encrypt certificates for `DOMAIN` and the HTTP→HTTPS redirect. First: a DNS
  152. A (or AAAA) record for the domain pointing at the server, and ports 80 + 443
  153. open to the internet (port 80 is not optional — the certificate challenge and
  154. the redirect both use it).
  155. ```sh
  156. docker compose -f docker-compose.yml --profile https up -d
  157. ```
  158. **Behind your own reverse proxy** (Coolify, Traefik, nginx): skip the profile
  159. — two things terminating TLS for one app is one too many. Instead of `DOMAIN`,
  160. set the origin values and the proxy hop count in `.env`, so OAuth redirects
  161. are built right and rate limits see real client IPs instead of the proxy's:
  162. ```sh
  163. PUBLIC_BACKEND_URL=https://bevel.your-domain.com # public origin; OAuth redirects are built from it
  164. PUBLIC_FRONTEND_URL=https://bevel.your-domain.com # same origin: the backend serves the SPA
  165. TRUST_PROXY=1 # your proxy hop count
  166. ```
  167. ```sh
  168. docker compose -f docker-compose.yml up -d
  169. ```
  170. The explicit `-f` matters in a clone: it skips `docker-compose.override.yml`,
  171. so the app publishes **no host port** — your proxy reaches it on port `3001`
  172. over the compose network. This is deliberate: a fixed published port makes
  173. every redeploy fail with `port is already allocated`, because the replacement
  174. container starts while the outgoing one still holds it.
  175. Open your domain and sign in with `ADMIN_EMAIL` / `ADMIN_PASSWORD`.
  176. **Just trying it on your laptop?** Same steps, minus `DOMAIN` and the origin
  177. values — plus one extra file: `docker-compose.yml` alone publishes no host
  178. port (see above), and `docker-compose.override.yml` is the piece that puts
  179. the app on localhost. A clone already has it; next to the wget'd files, fetch
  180. it too:
  181. ```sh
  182. wget https://raw.githubusercontent.com/Bevel-Software/Hexis/v0.15.1/docker-compose.override.yml
  183. docker compose up -d
  184. ```
  185. Then open **http://localhost:3001** (a different port:
  186. `APP_PORT=8080 docker compose up -d`). Leave `TRUST_PROXY` unset here — with
  187. no proxy in front, trusting forwarded headers would let clients spoof their
  188. own address.
  189. ### First sign-in: the setup screen
  190. The app asks for the things it could not guess, and **tests them against the
  191. real host before saving**:
  192. 1. **Knowledge-base repo**: the https clone URL of that empty repository.
  193. 2. **Git credential**: a token with read/write access to it (for GitHub: a
  194. fine-grained personal access token with *Contents: read & write* on that one
  195. repo is enough).
  196. 3. **Branch model**: which branch is the default and which are protected
  197. (changes to protected branches only land through approved change requests).
  198. The repository's real branches are offered as suggestions; for an empty repo
  199. the default (`main`) is fine.
  200. Since the repo is empty, the app initialises it from the bundled template and
  201. writes a `roles.yaml` whose first Admin is you. That's it: you're in the
  202. workspace. Head to **Skills & Tools** to make your first plugin and skill, and to
  203. **Connect** (in the app menu) to hook up an agent over MCP.
  204. Going to production? [Configuration reference](docs/configuration.md) covers
  205. single sign-on, the state you need to back up, health checks, and configuring
  206. by environment instead of the setup screen.
  207. ## Links and images in knowledge pages
  208. Pages are markdown. A link to another page is a relative path, and Hexis opens
  209. it in the app:
  210. ```md
  211. See the [approval process](../Processes/Approval.md#steps).
  212. ```
  213. Images work the same way. Keep them in an `assets/` folder next to the pages
  214. that use them, and link them relatively:
  215. ```md
  216. ![Approval screen](./assets/approval-screen.png)
  217. ```
  218. Access follows folders, so a person who may read the page may see its
  219. screenshots, and moving the folder keeps every link valid; one shared
  220. `Uploads/` folder gives up both. An export that arrives with a sibling
  221. `.assets/` folder (Microsoft Loop, for one) can be dropped into the knowledge
  222. base as it is, and the links resolve unchanged. Pasted base64 images are not
  223. supported: save the file and link it.
  224. ## Local development (run from source)
  225. You need: **Node 22.13 or newer** (`.nvmrc`; the engine range is `>=22.13 <23`),
  226. **pnpm 10**, **git ≥ 2.41**, **ripgrep** (`rg` on your PATH — the agents' `grep` tool
  227. searches with it, and the server and the backend test suites refuse to run
  228. without it), and a Postgres 17 (the bundled one is fine):
  229. ```sh
  230. docker compose up -d db # just the database
  231. pnpm install
  232. pnpm build # builds the packages the apps import
  233. cp .env.example .env # fill the same four required values;
  234. # the default DATABASE_URL already points at the bundled db
  235. pnpm dev # backend on :3001, Vite dev server on :5173
  236. ```
  237. Open **http://localhost:5173** (the dev server proxies to the backend). Useful
  238. commands: `pnpm test`, `pnpm typecheck`, `pnpm lint`.
  239. Migrations run automatically on boot; there is no separate migrate step, in
  240. dev or in production.
  241. ## Reference
  242. - **[Configuration](docs/configuration.md)**: every environment variable, SSO
  243. setup, secret generation, backups and health.
  244. - **[Several knowledge bases in one process](docs/multi-tenant.md)**: the
  245. tenants file, what is kept apart, and moving a tenant to its own deployment.
  246. - **[Troubleshooting](docs/troubleshooting.md)**: the failures you are most
  247. likely to hit, and what causes them.
  248. ## Repository layout
  249. | Path | What it is |
  250. | --- | --- |
  251. | `packages/shared` | `@bevel-software/platform-shared`: shared types + pure domain utilities |
  252. | `packages/core-backend` | `@bevel-software/platform-core-backend`: the core backend (ships `migrations/` + `kb-template/`) |
  253. | `packages/core-frontend` | `@bevel-software/platform-core-frontend`: the core UI, published as raw TS/TSX source |
  254. | `apps/server` | standalone core backend shell |
  255. | `apps/web` | standalone core SPA shell (Vite) |
  256. ## FAQ
  257. Questions that come up when teams evaluate Hexis as a central, versioned
  258. catalogue for agent skills and tools.
  259. <details>
  260. <summary><b>How do agents find skills without flooding the context window?</b></summary>
  261. They look them up rather than loading them all: `list_skills` and `search`
  262. narrow the field, `get_skill` returns one skill at call time.
  263. </details>
  264. <details>
  265. <summary><b>How does an agent know what is in the knowledge base?</b></summary>
  266. Every MCP session starts with instructions: a fixed platform header that says
  267. what Hexis is and to search the knowledge base before answering from memory,
  268. followed by `mcp-description.md` from the root of your repository, where an
  269. admin describes what the knowledge base holds and when to consult it. Clients
  270. that read the handshake (Claude Code, Claude Desktop, Cursor) put it in the
  271. system prompt; for the ones that do not, the first line is also shown on the
  272. four core tools. The External agent access page shows exactly what agents get.
  273. </details>
  274. <details>
  275. <summary><b>Which agents can connect?</b></summary>
  276. Any MCP-capable client, including Claude Code, Codex, Cursor, Cline and ChatGPT,
  277. each seeing only what its user's role allows.
  278. Agents that run on your own machine can instead start the workspace as a **local**
  279. MCP server (`npx -y @bevel-software/hexis-mcp`), which adds your plugins'
  280. local-only tools to everything the hosted endpoint serves. That command needs
  281. **Node 22.13+ or 24** — the versions its sandbox ships a prebuilt binary for —
  282. and a client launched from the Dock or a desktop icon may not see `npx` on PATH
  283. at all: run `which npx` (`where npx` on Windows) and use the full path it
  284. prints as the `"command"`. See
  285. [Troubleshooting](docs/troubleshooting.md#desktop-agents-the-local-mcp-server).
  286. </details>
  287. <details>
  288. <summary><b>How is the catalogue versioned?</b></summary>
  289. By git: every save is a commit, so history, blame and revert work as they do for
  290. code, and changes to protected branches ship as reviewable change requests.
  291. </details>
  292. <details>
  293. <summary><b>What governance do we get?</b></summary>
  294. Per-file access control, review-gated change requests, and a git audit trail of
  295. who changed what and who approved it.
  296. </details>
  297. License: [Apache-2.0](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

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