Least privilege for agents and humans

The network stack built from the ground up for the agentic era. Reverse and forward proxies that keep credentials out of agents’ and humans’ hands, enforce fine-grained policies, and audit every action.

Key use cases
Secure AI Agents & MCP
Proxy between AI agents and MCP servers. Strip PII before it hits the LLM, block unauthorized tool calls, enforce permissions the upstream system lacks, and audit every agent action.
Database Access Governance
Centralized access control across hundreds of databases. Short-lived credentials, JIT access via Slack/Jira, Okta-integrated provisioning. No more standing privileges or forgotten service accounts.
PII/PHI Masking & Compliance
Query-level data masking for HIPAA, SOC 2, PCI DSS, GDPR. Analysts see ***, admins see real data — based on role. No code changes.
BI Tool Security
Secure Metabase, Looker, and Tableau connections to production. Column-level restrictions, query auditing, stale-account detection.
SSH & Infrastructure Session Auditing
Full session recording for SSH, Kubernetes, and RDP. LLM-powered anomaly detection flags suspicious commands and privilege escalation in real time.
How it works

Deploy a single stateless binary in your VPC via Terraform, Kubernetes, or Docker. Point connection strings through Formal instead of directly to your datastores. Every identity — engineer, BI tool, CI/CD pipeline, AI agent — hits the proxy, where policies evaluate in real time. No app changes, no SDK.

See the quickstart guide →
Authenticate / Authorize
Mask / Filter / Rewrite
Log / Monitor / Alert

+------------------+      +------------------+      +------------------+
|  Identities      | ---> | Formal Proxy     | ---> |  Resources       |
+------------------+      +------------------+      +------------------+

Response path: identities <--- formal proxy <--- resources
Examples: idp users, CI/CD, BI tools, AI agents | postgres, mysql, mongodb, snowflake, k8s, http, mcp

See the full architecture →

Killer features
Panopticon Auditability
Every query, session, and policy decision — logged with full context across every protocol. Who ran what, when, from where, against which resource. Sub-second search across your full history. Ship to Splunk, Datadog, or S3.
Wire-Protocol-Level Query Rewriting
Native wire-protocol parsing for Postgres, MySQL, MongoDB, MCP, and more — rewriting queries, masking columns, and filtering data inline. Same for AI agent tool calls: intercept, strip sensitive fields, enforce least privilege before anything reaches upstream.
9 Policy Actions, Multi-Stage Pipeline
Allow, Block, Mask, Filter, Rewrite, Quarantine, Suspend, MFA, Impersonate. Evaluated at 3 stages: session, request, response. No other product has this range of inline actions.
Policy Impact Reports & Backtesting
“What-if” analysis: test a new policy against up to 31 days of historical logs before enforcing it. See exactly which queries would be blocked or masked. Avoid breaking production.
Single Binary, 15+ Protocols
One stateless binary handles Postgres, MySQL, MongoDB, Snowflake, SSH, Kubernetes, HTTP, MCP, S3, Redis, RDP, gRPC, BigQuery, ClickHouse, and DynamoDB. Native wire-level parsing — not generic TCP passthrough. Deployed in your VPC. See the protocol reference →
Real-Time AI Session Monitoring
LLM-powered behavior analysis embedded in the proxy. Detects anomalies in live SSH sessions, flags suspicious kubectl commands, and catches unusual SQL patterns as they happen.
Deploy in minutes, not months
1. Deploy the proxy

One stateless binary in your VPC via Terraform, Kubernetes, or Docker. Most teams route first traffic in under an hour — Notion secured hundreds of datastores in days.

Read how →
2. Define your policies

Use the no-code editor or write Rego policies. Set masking rules, access controls, and approval workflows. Test with dry-run before going live.

3. Enforce everywhere

Every query, every protocol, evaluated in real time. Full visibility, automatic compliance, least privilege on autopilot.

For developers

Security as Code

API-first. Choose your IaC, pick your VPC, deploy a single distroless image to protect your entire stack.

See docs →
Terraform
Build with
Terraform
Pulumi
Build with
Pulumi
Build with
API
# Connect a resource
resource "formal_resource" "production_pg" {
  name       = "production-postgres"
  technology = "postgresql"
  hostname   = "db.internal.company.com"
  port       = 5432
}

# Mask PII for non-privileged users (Rego)
resource "formal_policy" "mask_pii" {
  name        = "mask-pii-data"
  description = "Mask PII fields for non-privileged users"
  status      = "active"

  module = <<-EOT
    package formal.v2
    import future.keywords.if
    import future.keywords.in

    response := {
      "action":  "mask",
      "type":    "nullify",
      "columns": pii_columns
    } if {
      not "pii_access" in input.user.groups
      pii_columns := [col |
        col := input.columns[_]
        col.data_label in ["email", "ssn", "phone"]
      ]
      count(pii_columns) > 0
    }
  EOT
}
Why Formal

One policy engine, both directions

The forward and reverse proxies share the same OPA policy engine and protocol parsers. Write a policy once and it governs both what leaves your machines and what reaches your infrastructure.

Protocol-native at every hop

Formal parses Postgres, MySQL, SSH, Kubernetes, HTTP, MCP, and more on the wire, so every decision is made per query, command, and tool call — not per IP and port.

Identity on every request

Every action is tied to who made it: the engineer, the agent, and the person the agent is acting for. Permissions are checked against the human behind the task.

Runs in your infrastructure

The reverse proxy runs in your VPC and the forward proxy on the machines your agents run on. Your data stays in your infrastructure, with single-digit-millisecond overhead at p50.

Ready to trust your agents?

One network security layer for every agent and human, from the laptop to production.