Bevel
Bevel is a vendor-agnostic, git-backed control plane for enterprise AI agents that defines agents, context, skills, tools, permissions, and identity as files you own and serve to any agent runtime over MCP/UTCP.
https://www.bevel.software/?ref=producthunt
Product Information
Updated:Aug 14, 2026
What is Bevel
Bevel is a Munich-based (est. 2024) control plane designed to help organizations operationalize AI agents without locking their core agent logic and governance inside a single vendor’s product. Instead of scattering prompts, tool wiring, knowledge, and access controls across multiple consoles and connector panels, Bevel makes your repository the single source of versioned truth. It lets teams define what agents know, how they behave, what they’re allowed to do, and who they act as—using plain Markdown and YAML stored in your infrastructure—so the same governed agent setup can be consumed by different agent runtimes across the company.
Key Features of Bevel
Bevel is a vendor-agnostic, git-backed control plane for enterprise AI agents that lets organizations define agents’ context, skills, tools, permissions, and identity as plain files (Markdown/YAML) stored in their own infrastructure and served to any agent runtime via MCP (and related protocol tooling). It centralizes governed, versioned “source of truth” for agent knowledge and procedures, enforces fine-grained access rules and per-agent credentials, and makes changes reviewable through standard git workflows (branches, diffs, change requests) so teams can scale agent deployment across both employee-facing and unattended/background automation with strong attribution and control.
Git-backed agent configuration as files: Defines agents, knowledge, skills, tool manifests, and access policies in Markdown/YAML in your own repo—using standard git branches, diffs, and reviews instead of vendor-specific consoles.
Typed context graph with provenance: Stores knowledge as typed nodes with provenance (source, last editor, verification time) and compiles it into a traversable graph for updates, audits, and dashboards.
Skills as readable, reviewable procedures: Encodes operational procedures in plain Markdown (not buried prompt fragments), making them understandable to process owners and portable across agent runtimes.
Tool manifests + governed permissions: Declares tools once via manifests, keeps secrets in a vault, and applies access rules that control which agent can read which files or call which endpoints—changes go through review.
Per-agent identity and attribution: Each agent is a named actor with its own credentials and scoped access (no shared service accounts), improving auditability and accountability for actions taken.
Runtime-agnostic delivery over MCP: Serves the same governed agent surface to multiple runtimes (e.g., desktop coding assistants and server-side/background agents) so you can switch or mix vendors without re-building.
Use Cases of Bevel
Procurement & sourcing copilots: Create agents for RFIs, tender management, and supplier qualification by combining versioned procedures (skills) with controlled access to internal documents and procurement tools.
GTM campaign automation: Unify fragmented data across systems like Salesforce and ad platforms, then run campaign-planning/execution agents with governed tool access and reusable context.
Market intelligence agents: Bridge external market data with internal signals to deliver curated insights to the right teams, while keeping sources, edits, and verification traceable via provenance.
Enterprise-wide agent governance & compliance: Standardize how all teams define agent knowledge, permissions, and identities; enforce least-privilege access and auditable change control through git review workflows.
Multi-runtime agent portability (anti-vendor lock-in): Run the same agents across different runtimes (interactive desktop assistants and unattended background agents) without re-implementing connectors, prompts, or knowledge stores per vendor.
Pros
Vendor-agnostic design reduces lock-in by keeping agent definitions and knowledge in your infrastructure and serving any runtime via MCP.
Strong governance: file-level access rules, vault-held secrets, per-agent identity, and git-based review improve security and auditability.
Operational clarity: skills in Markdown and provenance-backed context make agent behavior easier to understand, maintain, and improve over time.
Cons
Requires disciplined repo/process ownership (information architecture, reviews, and maintenance) to keep context and skills accurate and useful.
Adoption may involve upfront integration and policy design work (tool manifests, permissions modeling, identity setup) before value is realized.
Teams accustomed to vendor UIs may face a learning curve moving to file-based, git-centric workflows for agent management.
How to Use Bevel
1) Decide which “Bevel” you mean: The sources reference multiple unrelated products named “Bevel” (an enterprise AI agent control plane at bevel.software, a health app, Blender’s bevel tool, etc.). The official site provided is Bevel (Git-backed control plane for enterprise AI agents). The steps below cover that Bevel.
2) Create (or choose) a Git repository that will be your source of truth: Bevel’s model is “your repo is the source of truth.” Create a repository in your company’s infrastructure where agent context, skills, tools, identities, and access rules will live as files.
3) Add the standard Bevel folder structure: Organize your repo into the file-based layout described on the official site, e.g. knowledge/, skills/, tools/, agents/, access/ so everything is versioned and reviewable via Git.
4) Define what the agent knows (Context): Populate knowledge/ with typed knowledge nodes that include provenance for facts (where it came from, who last touched it, when it was verified). This context is compiled into a graph you can traverse, mass-update, and build dashboards on.
5) Define how the agent works (Skills): Write procedures as plain Markdown files in skills/ (not prompt fragments in a vendor console). Keep them readable by process owners and reviewable in diffs.
6) Declare tools and how they’re exposed (Tools manifests): Create tool manifest files in tools/ (e.g., salesforce.yaml, sharepoint.yaml). These manifests declare tools once so they can be served to any agent runtime over MCP/UTCP.
7) Configure secrets handling for tools: Ensure tool secrets are held in a vault (per the official site: “tool manifests with secrets held in a vault”). Keep secrets out of Git; store only references/metadata needed for retrieval.
8) Define what each agent may do (Permissions / access rules): Create file-level access rules under access/ (e.g., policy.yaml) that specify which agent may read which file and call which endpoint. Route changes through code review like any other change.
9) Define who the agent acts as (Identity): Create per-agent identities so each agent is a named actor with its own credentials and scope (not a shared service account). This makes actions attributable to a specific agent.
10) Assemble an agent definition: Create an agent configuration file in agents/ (e.g., tender-desk.yaml) that ties together the four parts: context references, skill procedures, tool access, and identity/scope.
11) Connect an agent runtime via MCP or UTCP: Serve the repo-defined context/skills/tools/permissions to the runtime “over MCP” (and/or UTCP as described). The official site lists supported runtimes such as Claude Code, Cursor, ChatGPT desktop, opencode, background agents, and in-platform self-hosted models.
12) Verify governed access behavior: Test that “agents connect and read exactly what they’re permitted to read” by attempting reads/calls inside and outside the defined access policy, confirming that unauthorized files/endpoints are blocked.
13) Operate via Git workflows (branches, change requests, diffs): Make updates by editing Markdown/YAML, opening change requests, and reviewing diffs. This is the primary operating model: governance and evolution happen through standard Git practices rather than vendor-specific consoles.
14) Maintain and evolve reusable context and skills: Continuously update the shared artifacts (knowledge nodes, skills, tool manifests, policies) so improvements become durable “reviewed edits to the artifact everyone shares,” rather than being lost in chat transcripts.
Bevel FAQs
Bevel is a vendor-agnostic, Git-backed control plane for enterprise AI agents. It lets a company define its AI agents’ context, skills, tools, permissions, and identity as files the company owns in its own infrastructure, and serve them to any agent runtime over MCP.
Bevel Video
Popular Articles
Atoms: A Multi-Agent AI Platform That Transforms Ideas into Launch-Ready Products
May 22, 2026
Nano Banana SBTI: What It Is, How It Works, and How to Use It in 2026
Apr 15, 2026
Atoms Review — The AI Product Builder Redefining Digital Creation in 2026
Apr 10, 2026
Kilo Claw: How to Deploy and Use a True "Do‑It‑For‑You" AI Agent(2026 Update)
Apr 3, 2026
Latest AI Tools Similar to Bevel
Gait
Gait is a collaboration tool that integrates AI-assisted code generation with version control, enabling teams to track, understand, and share AI-generated code context efficiently.
invoices.dev
invoices.dev is an automated invoicing platform that generates invoices directly from developers' Git commits, with integration capabilities for GitHub, Slack, Linear, and Google services.
EasyRFP
EasyRFP is an AI-powered edge computing toolkit that streamlines RFP (Request for Proposal) responses and enables real-time field phenotyping through deep learning technology.
Cart.ai
Cart.ai is an AI-powered service platform that provides comprehensive business automation solutions including coding, customer relations management, video editing, e-commerce setup, and custom AI development with 24/7 support.
Popular AI Tools Like Bevel
GitHub Copilot Chat
GitHub Copilot Chat is an AI-powered coding assistant that provides natural language interactions, real-time code suggestions, and contextual support directly within supported IDEs and GitHub.com.
CopilotForXcode
CopilotForXcode is an Xcode Source Editor Extension that integrates GitHub Copilot, Codeium, and ChatGPT to provide AI-powered code suggestions, chat assistance, and prompt-to-code functionality within Xcode.
BrowserAI
BrowserAI is an open-source library that enables running local Large Language Models (LLMs) directly in web browsers with WebGPU acceleration, offering privacy-focused AI capabilities without requiring server infrastructure.
OpenAI Codex CLI
OpenAI Codex CLI is a lightweight, open-source coding agent that runs in your terminal, enabling developers to translate natural language into code execution while providing ChatGPT-level reasoning with the ability to run code, manipulate files, and iterate under version control.