convez.ai
MCP ServerSegurançaAvançado
Mindburn-Labs

HELM AI Kernel

Mindburn-Labs/helm-ai-kernel

Firewall fail-closed com isolamento de ferramentas e auditoria assinada para agentes IA

Ver no GitHub
BomPluginScore · de 0 a 100

Firewall de execução fail-closed para agentes de IA que quarentena ferramentas MCP, faz proxy de requisições OpenAI-compatíveis, emite recibos assinados e verifica EvidencePacks offline. Fornece controle de segurança rigoroso para ambientes de agentes autônomos com assinatura criptográfica de operações.

Instalação

$npx convez-ai Mindburn-Labs/helm-ai-kernel

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
61
Forks
5
Acompanhando
2
Saúde
100%
Último commit
há 1 dia
Versão
v0.12.0
Issues abertas
21
Contribuidores
7

Casos de uso

  • Executar agentes IA com controle rigoroso de segurança em ambientes de produção
  • Quarentena e proxy de chamadas MCP para validação antes de execução
  • Auditoria criptográfica e verificação offline de operações de agentes

Veredito

Solução enterprise-grade para governança de agentes IA com arquitetura fail-closed, assinatura criptográfica e verificação offline. Altamente recomendado para deployments críticos que exigem auditoria e controle granular.

README

A tradução para o português deste README ainda está na fila.

HELM AI Kernel

License: Apache 2.0 CI Documentation Gates CodeQL OpenSSF Scorecard OpenSSF Best Practices Release Maven Central npm PyPI crates.io Go Reference Launchpad Artifacts Release checksums Release attestations SBOM CycloneDX SLSA provenance Sigstore Cosign GHCR kernel GHCR chart Artifact Hub

HELM AI Kernel is the fail-closed execution firewall for AI agents.

Mindburn Labs' HELM execution kernel for AI agents, not the Kubernetes package manager.

HELM evaluates agent execution requests and records every ALLOW / DENY / ESCALATE decision as verifiable evidence.

Try HELM AI Kernel Locally

No account, hosted service, or production credential is required for the local proof path:

git clone https://github.com/Mindburn-Labs/helm-ai-kernel.git
cd helm-ai-kernel
make build
bash scripts/launch/demo-mcp.sh
bash scripts/launch/demo-proof.sh

The local proof path shows the public value proposition in one frame:

  • unknown MCP servers and tools are denied before fixture dispatch
  • a schema-pinned fixture call is allowed
  • a signed DENY receipt verifies offline
  • a flipped-verdict receipt fails verification

Star HELM AI Kernel if you want to follow fail-closed AI agent execution, MCP quarantine, signed receipts, and offline-verifiable EvidencePacks: https://github.com/Mindburn-Labs/helm-ai-kernel/stargazers

HELM MCP quarantine and receipt proof board

Sanitized transcripts are checked in under examples/launch/assets.

Start Here

VisitorFirst pathWhat to verify
Agent buildersQuickstart and OpenAI-compatible proxyExisting OpenAI-style clients can route through HELM and receive receipt metadata.
Security engineersExecution Security Model and OWASP MCP Threat MappingALLOW, DENY, and ESCALATE decisions are recorded with verifiable evidence.
Gateway and MCP maintainersMCP integration and Ecosystem mapUnknown tools stay quarantined until schema, identity, and policy state are approved.

Community And Product Links

Launchpad And Console

brew install mindburnlabs/tap/helm-ai-kernel
helm-ai-kernel login
helm-ai-kernel console pair

export OPENROUTER_API_KEY=...
helm-ai-kernel launch secrets set model_gateway \
  --provider openrouter \
  --value-env OPENROUTER_API_KEY

helm up openclaw
helm up hermes --target local

helm-ai-kernel launch evidence <launch_id> --export --json
helm-ai-kernel verify --bundle <pack>

Native EvidencePack verification is sealed by 07_ATTESTATIONS/evidence_pack.sig. Dev-local packs verify offline with the default profile. Customer-grade packs use the same seal plus explicit trust configuration, external signing, an external Rekor or RFC3161 anchor receipt, and an S3 Object Lock storage receipt:

helm-ai-kernel trust init --config helm/helm.yaml --profile customer --signer kms --anchor rekor --store s3 --object-lock
helm-ai-kernel verify --bundle <pack.tar> --profile customer --storage-receipt <pack.tar.storage.json>

What you get:

  • Console dashboard with receipts, evidence, and run history
  • deterministic ALLOW / DENY / ESCALATE verdicts
  • MCP quarantine for unknown servers and tools
  • signed receipts
  • offline-verifiable EvidencePacks
  • teardown proof

Core Overview

AI models propose. Deterministic systems govern. HELM sits between stochastic agent tool calls and infrastructure side effects. It intercepts MCP tools and OpenAI-compatible requests, evaluates authority before dispatch, and emits signed receipts that can be verified offline.

This is Mindburn Labs' HELM execution kernel for AI, not the Kubernetes package manager.

Agent proposal -> HELM boundary -> ALLOW / DENY / ESCALATE -> signed receipt

Status

  • Repository: Mindburn-Labs/helm-ai-kernel
  • Root package identity: helm-ai-kernel-root
  • Source release target: v0.5.10
  • License: Apache-2.0
  • Supported security line: 0.5.x; 0.4.x is best effort
  • Canonical docs: https://helm.docs.mindburn.org/helm-ai-kernel

The v0.5.10 release is complete only when the GitHub Release includes CLI binaries, checksums, SBOM JSON, OpenVEX, release-attestation metadata, Cosign bundles, evidence-pack.tar, helm-ai-kernel.mcpb, helm-ai-kernel.rb, sample policy material, and a passing version-status.json for all lockstep package channels: https://github.com/Mindburn-Labs/helm-ai-kernel/releases/tag/v0.5.10.

What HELM AI Kernel Does

  • Enforces default-deny execution for agent tool calls.
  • Wraps MCP servers so unknown tools can be quarantined before side effects.
  • Runs the kernel, guardian, proxy, receipt store, evidence export, and verification paths.
  • Produces signed receipts and EvidencePacks for replay, audit, and tamper checks.
  • Ships public SDK sources for Go, Python, TypeScript, Rust, and Java.

HELM AI Kernel does not include hosted Mindburn operations, private operational tooling, or non-OSS downstream extensions.

Quick Start

Register at https://console.helm.mindburn.org to create your account, then install the published macOS CLI from the current GitHub release. The public Homebrew tap is current only when the release includes a passing version-status.json.

curl -L -o helm-ai-kernel https://github.com/Mindburn-Labs/helm-ai-kernel/releases/latest/download/helm-ai-kernel-darwin-arm64
chmod +x helm-ai-kernel
./helm-ai-kernel --version

Start a local headless boundary:

helm-ai-kernel serve --policy ./release.high_risk.v3.toml
helm-ai-kernel boundary status

Run the local proof demo after helm-ai-kernel serve starts on 127.0.0.1:7714:

curl http://127.0.0.1:7714/api/demo/run \
  -H 'content-type: application/json' \
  -d '{"action_id":"export_customer_list","policy_id":"agent_tool_call_boundary"}'

Verify the returned receipt and confirm that tampering fails:

curl http://127.0.0.1:7714/api/demo/verify \
  -H 'content-type: application/json' \
  -d '{"receipt":{...},"expected_receipt_hash":"<receipt_hash from proof_refs>"}'

curl http://127.0.0.1:7714/api/demo/tamper \
  -H 'content-type: application/json' \
  -d '{"receipt":{...},"expected_receipt_hash":"<receipt_hash from proof_refs>","mutation":"flip_verdict"}'

Govern MCP tools or an OpenAI-compatible client:

python3 scripts/launch/mock-openai-upstream.py --port 19090
helm-ai-kernel mcp wrap --server-id local-tools --upstream-command "python3 scripts/launch/mcp-fixture-server.py"
helm-ai-kernel proxy --upstream http://127.0.0.1:19090/v1

Inspect and verify evidence:

helm-ai-kernel sandbox preflight --runtime wazero
helm-ai-kernel receipts tail --agent agent.demo.exec
helm-ai-kernel verify evidence-pack.tar

helm-ai-kernel serve --policy stores receipts in SQLite by default unless DATABASE_URL is set. helm-ai-kernel verify evidence-pack.tar runs offline by default; use --online only when public proof endpoint credentials are available for that release.

Build From Source

git clone https://github.com/Mindburn-Labs/helm-ai-kernel.git
cd helm-ai-kernel
make build
./bin/helm-ai-kernel serve --policy ./release.high_risk.v3.toml

Run the retained validation targets before publishing changes:

make test
make test-platform
make test-all
make crucible

Architecture

HELM separates orchestration from execution authority. Agent frameworks decide what to attempt; HELM decides what is allowed to execute.

flowchart LR
    Agent["Agent tool call"] --> Boundary["HELM boundary"]
    Boundary --> Verdict["ALLOW / DENY / ESCALATE"]
    Verdict --> Receipt["Signed receipt"]
    Receipt --> Verify["Verify / replay"]
    Verify --> Tamper["Tamper fails"]

Unknown MCP servers and tools enter quarantine before dispatch:

flowchart TD
    Server["Discovered MCP server"] --> Quarantine["Quarantined by default"]
    Quarantine --> Inspect["Metadata and schema inspection"]
    Inspect --> Risk["Risk classification"]
    Risk --> Approval["Approval record"]
    Approval --> Active["Policy-bound active state"]
    Active --> Decision["ALLOW / DENY / ESCALATE"]
    Decision --> Proof["Receipt and ProofGraph event"]

Key terms:

  • ALLOW: HELM lets the action run.
  • DENY: HELM blocks the action.
  • ESCALATE: HELM stops and asks for more facts, policy, or human approval.
  • Receipt: signed record of the decision.
  • ProofGraph: replayable record chain for what happened.
  • EvidencePack: portable bundle of records for a review path.

The complete diagram doctrine lives in docs/architecture/canonical-diagrams.md.

Public Interfaces

SurfacePathStatus
CLI and kernelcore/Go implementation of boundary, CLI, HTTP API, proxy, receipts, evidence export, and verification
Headless API contractapi/openapi/, protocols/, schemas/HTTP, WebSocket-adjacent, OpenAPI, Protobuf, policy schema, and JSON schema contracts for external clients
Wire contractsapi/openapi/, protocols/, schemas/OpenAPI, Protobuf, policy schemas, and JSON schemas
SDKssdk/Go, Python, TypeScript, Rust, and Java sources
Examplesexamples/Runnable integrations and launch smoke material
Conformancetests/conformance/, reference_packs/Profile, checklist, fixtures, and reference packs
Deploymentdeploy/helm-chart/Helm chart for running the kernel in Kubernetes

SDKs And Packages

SurfaceCurrent install or status
CLIGitHub Release binaries; the latest release attaches a helm-ai-kernel.rb formula asset. Verify the public tap before relying on brew install mindburnlabs/tap/helm-ai-kernel for the latest version
Go SDKgo get github.com/Mindburn-Labs/helm-ai-kernel/sdk/go@main; tagged module versions are tracked as an OSS-readiness follow-up
Python SDKpip install helm-sdk
TypeScript SDKnpm install @mindburn/helm-ai-kernel
Rust SDKcargo add helm-sdk
Java SDKMaven Central coordinate io.github.mindburnlabs:helm-sdk:0.5.10

HTTP clients are generated from api/openapi/helm.openapi.yaml. Protobuf message bindings come from protocols/proto/ where a language SDK ships them.

Documentation

Public OSS docs are sourced from this repo and published through helm.docs.mindburn.org. The owned docs set for sync is declared in docs/public-docs.manifest.json.

Release Verification

For v0.5.10, verify downloads with SHA256SUMS.txt, sbom.json, v0.5.10.openvex.json, release-attestation.json, the platform binary assets, matching *.cosign.bundle files, and offline evidence-pack.tar verification.

Current release tooling requires tag refs to match the checked-in VERSION, requires an exact v<version>.openvex.json for tag releases, and verifies the staged evidence-pack.tar before checksums are finalized.

See docs/VERIFICATION.md and docs/PUBLISHING.md for the full release verification path.

Security, Contributing, And Governance

License

Apache-2.0. See LICENSE.

Ver o original no GitHub

Bom para

Relacionados