Hipocap

Hipocap

Hipocap · Productivity · Other

Hipocap is an open-source DevSecOps platform that sits between an AI agent and its tools, blocking prompt injections and enforcing function-level access rules before they run.

Interface preview of Hipocap

About Hipocap

What Is Hipocap

Hipocap is an open-source platform for securing and governing AI agents while they work. Instead of watching an agent after it has leaked data or called the wrong tool, Hipocap stands in front of each tool call and decides if it should run at all. It ships under Apache 2.0, so you can run the whole stack yourself or pay for a managed cloud setup through a demo.

The product bundles three jobs that teams usually buy separately. A security shield scans every function call for prompt injection and other threats. A role-based access layer enforces who is allowed to call what, down to single functions. An observability layer traces every step an agent takes, from the prompt to the tool result. Because the pieces share one data path, blocked calls and allowed calls both land in the same audit trail.

The main limit is language and maturity. The security shield only supports Python today, so TypeScript teams get tracing but not the runtime protection. The project is also young, launched in early 2026 with a small community, so it suits teams willing to self-host and read the docs rather than wait for a polished enterprise suite.

Getting Started

  1. Clone the repository from GitHub and start the stack with Docker Compose, which brings up the dashboard, the security server and the data stores.
  2. Create a project in the dashboard, then copy your API key and user ID from project settings.
  3. Install the Python SDK with pip, then call Hipocap.initialize in your app before your first LLM call.
  4. Write a policy that sets roles, allowed functions and severity rules, and create a shield if you want to block direct prompt injection by description.
  5. Wrap functions with the observe decorator and call analyze inside sensitive tools so each call gets checked and traced.

Product Information

A quick look at Hipocap's pricing, supported platforms, and performance.

Free PlanYes
Paid PlansCloud access by demo, custom pricing
PlatformSelf-hosted (Docker), Python SDK, web dashboard
DeveloperHipocap
CategoryProductivity · Other
Release DateJan 2026
Latest UpdatedAug 2025
Website Visits283
Website Global RankN/A
API AvailabilityYes

Best for

The users, tasks, and scenarios where this tool fits best.

Users

  • Engineering teams shipping AI agents
  • Security and platform engineers
  • Teams wary of cloud lock-in

Tasks

  • Blocking prompt injection
  • Enforcing least privilege
  • Tracing agent runs
  • Reviewing risky calls

Scenarios

  • Moving an agent from demo to production
  • Investigating an incident
  • Meeting a compliance check

Key features

Runtime Prompt Injection Defense

Hipocap checks a function call before it executes, so threats are stopped rather than logged after the damage. The shield runs three stages: a fast prompt guard for obvious patterns, an LLM analysis pass for structured threats, and a quarantine stage that simulates what a suspicious document would do if an agent processed it. That third stage targets indirect injections hidden inside emails or web pages, which are the hardest to catch.

Function-Level RBAC

Access control here works at the level of individual functions, not the whole app. You map roles to allowed tool calls, so an admin can send and delete email while a guest can only read. The check runs in the shield's RBAC engine before the function body executes, which means an unauthorized call never reaches your code. It's the difference between a permission that's only logged and one that's actually enforced.

Custom Shields

Shields are prompt-based rules for blocking direct prompt injection. You describe in plain language what the shield should watch for, what to block and what to allow, and give it a key your code references. That makes it possible to target specific cases, like a jailbreak attempt or a system prompt leak, without writing detection logic yourself. Each shield is created in the dashboard and called from your app.

Function Chaining Rules

Some risks come from the order of calls, not any single one. Hipocap lets you restrict which functions may run together, blocking sequences such as read email followed by send email that would quietly forward data out. Chaining rules sit alongside the role checks, so a chain is evaluated as a whole before the agent proceeds. According to Hipocap, this catches unauthorized workflows that pass every individual permission.

OpenTelemetry-Native Tracing

The observability layer traces agent runs and works with common stacks. It auto-instruments OpenAI, Anthropic, LangChain and others, stores traces you can query with SQL, and ties security decisions to the same trace as the call. You can filter, search and build custom dashboards on top of the data. The tracing core comes from Laminar, so much of the tooling and structure will feel familiar to teams already using that platform.

Data Masking for Debugging

The platform can redact sensitive values in logs so engineers can debug without reading customer secrets. Because the security layer and the observability layer share one path, masking applies to what gets recorded, not just what gets shown. That keeps personal data out of trace storage, which matters for teams under privacy rules. It runs as a mode you turn on rather than something you code per project.

Pros and cons

Pros

  • Enforces security and permissions before a tool call runs, so blocked actions never reach your code.
  • Combines prompt injection defense, RBAC and tracing in one stack instead of three separate tools.
  • Open source under Apache 2.0 and self-hostable with Docker Compose, so you can keep data in-house.
  • Ships a Python SDK with a decorator and an analyze call, so adding checks to sensitive functions is a small change.
  • The observability core comes from Laminar, so tracing, SQL access and dashboards are already mature.

Cons

  • The security shield only supports Python, so TypeScript and JavaScript teams get tracing but not runtime protection.
  • The project is young and the community is small, so you'll lean on the docs and the source rather than a large support community.
  • Cloud access is gated behind a demo booking with custom pricing, so there is no self-serve paid plan or public price list.
  • Self-hosting means running and maintaining the database, ClickHouse and search services that the stack depends on.

Frequently asked questions

Hipocap is an open-source DevSecOps platform for AI agents. It sits between your agent and its tools to block prompt injection and enforce function-level access rules before a call runs, and it traces every step the agent takes for later review.