Dynax — Enterprise Security for the AI Era
Request a demo

dynax — enterprise security for the AI era

Every action.
Every identity.
Authorized at machine speed.

Humans, AI agents, and services hit your systems thousands of times a second — and every request asks the same question: is this allowed? Dynax is authorization as a service: model your rules once, enforce them in every app and agent, and get the answer in milliseconds.

Request a demo

dynax://platform/model

Model it once

Authorization logic doesn't belong in if-statements scattered across your codebase. With Dynax you express who can do what in one declarative policy — readable, reviewable, and versioned like the rest of your code.

  • Building blocks, not boilerplate: roles, relationships, and attributes compose into exactly your rules.
  • One source of truth shared by every app, service, and AI agent you run.
  • Policy as code — reviewed in pull requests, shipped like software.
● app.dynax.co/policy — policy.dyx
# Who can do what, in one place
actor User, Agent, Service
resource Report {
roles = ["viewer", "editor"]
permissions = ["read", "update", "delete"]
"read" if role(actor, "viewer")
"update" if role(actor, "editor")
"delete" if role(actor, "editor")
and active_task(actor, resource)
}
policy valid · 14 rules · deployed as v42

dynax://platform/enforce

Enforce it everywhere

Every sensitive action becomes one question: is this actor allowed to do this? Your apps and agents ask, Dynax answers — in milliseconds, from the same policy, at any scale.

  • One check API in front of every sensitive action — human or agent.
  • List endpoints answer "what can they see?" to drive UIs and database queries.
  • Built for agents: every tool call checked before it runs, not audited after.
● app.dynax.co/console — check API
→ POST /v1/check · 3ms
{ actor: "user:a.okafor", action: "read", resource: "report:q3" }
← ALLOW role: viewer, via team:finance
→ POST /v1/check · 4ms
{ actor: "agent:openclaw-batch", action: "delete", resource: "db.customers" }
← DENY no active task covers this resource
→ POST /v1/list · 6ms
{ actor: "user:j.rivera", action: "read", resource_type: "report" }
← 12 results of 3,408 — only what this actor may see

dynax://platform/explain

Explain every decision

Authorization you can't test is authorization you can't trust. Write tests for your policy, dry-run changes before they ship, and when a decision surprises you, ask why — Dynax shows the exact rules and relationships behind every allow and deny.

  • Policy tests in CI, so rule changes never ship blind.
  • Dry runs preview a change against real traffic before rollout.
  • Ask why: trace any decision to the rules and data behind it.
● app.dynax.co/explain — decision trace
⌕ Which non-human identities can delete customer data in prod? 3 PATHS FOUND
agent openclaw-batch role:etl-admin → policy:prod-rw → db.customers/DELETE
service svc-retention-job sa:retention → binding:lifecycle → db.customers/DELETE
agent claude-code · delegated grant:task#4821 → scoped:staging only — prod denied

dynax://services

Operators, not observers.

Software finds the problem; someone still has to fix the org around it. Dynax Services embeds access-security specialists — people who have run authorization at planetary scale — alongside your team until the outcome is real and measured.

dynax://services/zero-trust

Zero-Trust Consulting

Most zero-trust programs stall at the network layer. We take you past it — to per-action authorization for humans and AI agents.

  • Maturity assessment against the BeyondZero model, scored per system and per identity class.
  • Invariant design: the five to ten security statements that must always be true in your business.
  • Rogue-agent tabletops: simulated agent incidents run against your real access paths.
  • Architecture roadmap: ReBAC for customers, ABAC for internal humans and agents, binary authorization for services.
a phased plan your board and your on-call both believe in
dynax://services/understanding

Access Understanding

You cannot defend what you cannot enumerate. We build the complete, truthful map of who — and what — can touch your data.

  • Identity census: every human, agent, service account, API key, and orphaned credential, catalogued.
  • Effective-permission mapping across clouds, SaaS, and data stores, resolved through every group and role hop.
  • Toxic-combination and dormant-privilege discovery, ranked by blast radius.
  • Audit-ready reporting your assessors accept the first time.
a single access snapshot, and a risk register ranked by evidence
dynax://services/remediation

Access Remediation

The snapshot tells you what to cut. We run the program that actually cuts it — without breaking production or the people in it.

  • Standing-privilege elimination: migrate humans and agents to just-in-time, task-bound grants.
  • Break-glass design so emergencies stay fast, logged, and rare.
  • Least-privilege campaigns with owner assignment, sequencing, and rollback plans.
  • Measured risk reduction: before/after snapshot deltas, reported monthly.
standing privileges near zero, with uptime intact
Weeks 0–2Map

Connect systems, build the snapshot, baseline every effective permission.

Weeks 2–6Model

Define invariants and identity classes; agree what "good" means.

Weeks 6–16Move

Execute remediation campaigns; convert standing access to task-bound.

OngoingHold

Continuous monitoring, quarterly invariant reviews, drift alerts.

dynax://company/overview

Access is the language of security.

Every breach, every insider event, every rogue-agent incident reduces to the same sentence: an identity took an action on a resource it should not have been able to touch. For decades the industry treated that sentence as unanswerable at scale — too many systems, too many roles, too much change.

"Our mission is to make least privilege real — for every human, every AI agent, and every service, on every action, at machine speed."— the Dynax founding memo, 2026

The AI era forced the question. When agents act thousands of times a second, quarterly access reviews are archaeology. Dynax was founded on the belief that authorization — not the network, not the endpoint — is the control plane of the AI-era enterprise, and that the same platform that secures our customers should govern us. We run Dynax on Dynax: zero standing privileges, every internal action task-bound and logged.

Dynax is headquartered in San Francisco, backed by leading security investors, and staffed by people who built and ran authorization systems at the largest scales in industry.

Trust is everything

Customers place enormous trust in us. We earn it daily — our security philosophy exists because their trust depends on it.

High trust, high speed

The market is enormous and moving. Good security is what lets us move fast — it is an accelerant, not a brake.

What we do inside, we do outside

The way we run access internally is the model we sell. We speak credibly about access because we live under our own controls.

dynax://company/careers — 6 open roles

Build the authorization layer for the AI era.

Small team, enormous surface. Every role touches the core problem: deciding, at machine speed, what an identity may do. All roles are San Francisco or remote (US), with meaningful equity.

Senior Software Engineer, Access SnapshotEngineeringSF / Remote+

Own the heart of Dynax: the distributed engine that resolves effective permissions at enterprise scale and answers authorization queries in single-digit milliseconds. You will set technical direction for the platform's most critical system and mentor the engineers building on it.

Responsibilities

  • Design and build the storage, indexing, and query layers of the Access Snapshot.
  • Drive latency and correctness guarantees for the real-time authorization decision path.
  • Lead design reviews; set standards for reliability across the platform team.
  • Work with founders on the technical roadmap for BeyondZero-model enforcement.

Minimum qualifications

  • Bachelor's degree in Computer Science, a related field, or equivalent practical experience.
  • 8 years of software development experience in one or more of Go, Rust, C++, or Java.
  • 5 years of experience with distributed systems, storage engines, or large-scale graph processing.
  • Experience leading projects and providing technical guidance to other engineers.

Preferred qualifications

  • Experience with authorization systems (Zanzibar-style ReBAC, ABAC engines, SpiceDB, OPA).
  • Experience operating multi-tenant systems with strict p99 latency budgets.
  • Contributions to open-source infrastructure or peer-reviewed systems publications.
  • Familiarity with the security properties of non-human and agent identities.
Apply — careers@dynax.co
Software Engineer, Access IntelligenceEngineeringSF / Remote+

Build the detection layer of Dynax: the models and pipelines that watch billions of authorization decisions and surface the handful that matter — privilege drift, task-scope violations, agents behaving outside their delegation.

Responsibilities

  • Build streaming pipelines that score authorization events in real time.
  • Develop anomaly-detection models specialized for human, agent, and service behavior.
  • Turn detections into explainable findings with evidence a responder can act on.
  • Partner with design on how risk is ranked and presented.

Minimum qualifications

  • Bachelor's degree in Computer Science, a related field, or equivalent practical experience.
  • 2 years of software development experience in one or more general-purpose languages.
  • Experience with data structures, algorithms, and building data-intensive services.

Preferred qualifications

  • Experience with stream processing (Flink, Kafka Streams) or ML in production.
  • Background in security analytics, UEBA, or identity threat detection.
  • Curiosity about how AI agents fail, and how to catch it early.
Apply — careers@dynax.co
Software Engineer, IntegrationsEngineeringSF / Remote+

The snapshot is only as good as its sources. Build and harden the connectors that pull identity and entitlement truth out of clouds, IdPs, databases, and SaaS — and push remediation safely back in.

Responsibilities

  • Design connectors for systems like AWS IAM, Entra ID, Okta, Snowflake, and GitHub.
  • Normalize wildly different permission models into the unified Access Snapshot schema.
  • Build the write path: revocations and grant changes executed idempotently, with rollback.
  • Own connector reliability, rate-limit behavior, and drift detection.

Minimum qualifications

  • Bachelor's degree in Computer Science, a related field, or equivalent practical experience.
  • 2 years of software development experience in one or more general-purpose languages.
  • Experience working with external APIs and distributed data synchronization.

Preferred qualifications

  • Deep familiarity with at least one cloud IAM model (AWS, GCP, or Azure).
  • Experience with the permission internals of databases or SaaS platforms.
  • A habit of reading other people's API docs so customers never have to.
Apply — careers@dynax.co
Product Designer, Access ExperiencesDesignSF / Remote+

Authorization data is some of the densest information in the enterprise: millions of identities, billions of edges, and decisions made in milliseconds. Your job is to make it legible — to give a security engineer at 3 a.m. the same clarity an auditor needs at quarter-end.

Responsibilities

  • Own end-to-end design for access exploration, monitoring, and remediation surfaces.
  • Design the visual language for identity classes, risk, and authorization decisions.
  • Prototype interactions for querying billions of access records without a query language.
  • Partner with engineering from problem definition through polished ship.

Minimum qualifications

  • Bachelor's degree in Design, HCI, a related field, or equivalent practical experience.
  • 4 years of product design experience, with a portfolio of shipped, data-dense product work.
  • Experience designing across the full stack: research, flows, visual systems, prototypes.

Preferred qualifications

  • Experience designing security, infrastructure, observability, or developer tools.
  • Fluency with data visualization and data-dense interfaces.
  • Experience building or evolving a design system in code with engineers.
Apply — careers@dynax.co
Forward Deployed Engineer — EnterpriseDeployedField / Travel ~50%+

You embed with our largest customers — banks, healthcare systems, AI labs — and own the outcome: standing privileges eliminated, agents governed, invariants enforced. You are the engineer in the room when the customer's hardest access problem meets our product, and you close that gap with code.

What you'll do

  • Deploy Dynax into environments with thousands of systems and decades of permission debt.
  • Write production integrations and automation on-site when the product doesn't reach yet.
  • Translate a CISO's mandate into invariants Dynax can enforce — then enforce them.
  • Feed what you learn in the field directly into the platform roadmap.

What we value

  • Strong engineering fundamentals; ability to ship in unfamiliar stacks under real constraints.
  • Degree in CS, engineering, math, or comparable technical depth from experience.
  • Composure with executives and on-call engineers alike; you earn trust in both rooms.
  • Bias for ownership: ambiguous problem, hostile timeline, still done.
  • Willingness to travel up to 50% to customer sites.

Why this role is different

  • You see the entire arc: first access snapshot to full BeyondZero-model enforcement.
  • Access security is decided in the field — this is where the mission gets real.
  • Small deployments, total ownership, direct line to founders.
Apply — careers@dynax.co
Forward Deployed Engineer — AI & AgentsDeployedField / Travel ~50%+

Our customers are deploying fleets of AI agents faster than they can govern them. You embed with their platform teams and make agent access safe: non-human identities issued, delegation modeled, every agent action bound to a task and logged. The frontier of this problem is in the field, and you'll be standing on it.

What you'll do

  • Design agent identity and delegation models for customers' real agent fleets.
  • Instrument agent frameworks so every tool call becomes an attributable, authorized action.
  • Run rogue-agent exercises against live (staged) environments and close what they expose.
  • Build the reference patterns that become product for every future customer.

What we value

  • Hands-on experience with LLM agents, tool use, and orchestration frameworks.
  • Strong engineering fundamentals; security instincts about what can go wrong at 2 a.m.
  • Degree in CS, engineering, math, or comparable technical depth from experience.
  • Clear writing — your field notes become company knowledge.
  • Willingness to travel up to 50% to customer sites.

Why this role is different

  • Nobody has fully solved agent authorization; you'll help define the standard.
  • Your work directly shapes the BeyondZero implementation the industry adopts.
  • You'll co-author what we publish — we share what the field teaches us.
Apply — careers@dynax.co

dynax://company/events

Where to find us.

AUG 01–062026 · Las Vegas, NV
Black Hat USA 2026

Dynax will be at Black Hat this year. If you're attending and want to talk about access in the AI era, we'd love to meet — reach out and we'll find time during the week.

Conference
SEP 172026 · Virtual
Continuous Authorization Live

A working session on continuous authorization: shrinking the trust boundary to the individual action, and what it takes to run zero standing privileges in production. Q&A with the Dynax field team.

Webinar
DEC 07–092026 · Grapevine, TX
Gartner Identity & Access Management Summit

Session: "Non-Human Identity Is Your Biggest Identity Program." Book time with the team in advance.

Conference
FIRST THUMonthly · San Francisco
Access Nights SF

An evening for people who think about authorization for a living. Short talks, hard problems, no vendor pitches — ours included. Hosted at Dynax HQ, Jackson Square.

Meetup

dynax://resources/access-philosophy

Our Authorization & Access Philosophy.

This is the document we run the company on — published in full because what we do inside, we do outside. It names our threats and states six invariants that must always hold.

The threats we design against

Rogue agents

No longer a futuristic scenario — our realistically biggest threat. We've already had agents do the wrong thing internally and cause production issues, and we expect the likelihood to rise. Even a well-aligned, intelligent agent is "rogue" if it lacks our business context: it can be doing what it believes is best for us and still not be doing what our customers need.

Insider threat

Sometimes people do the wrong thing — access abuse, IP theft, malicious outage. Increasingly these events are AI-assisted, so a neat boundary between human and agent threats isn't possible. Our controls treat them as one continuum.

Compliance

Less a threat than a standing need: a host of clear, verifiable controls across the business, enforcing security properties that must always be true — provable to auditors from live system state, not screenshots.

Three classes of identity

Human

Our own credentials and our own personal permissions — whether augmented by an agent (Claude Code) or delegated to one (Openclaw), the actions are ours.

Agent

Non-deterministic actors with separate, delegated non-human identities. Their next action comes from model inference, not fixed code — so they can be eval'd, but never statically tested.

Service

Service accounts running statically verifiable code in production. Trust flows from CI/CD and code review, enforced by binary authorization.

Six invariants

  1. Customer-authorized and internal-authorized traffic are cleanly separated.

    What customers do is attributable to them; what we do internally is attributable to internal identities. The two never blur.

  2. All internal access attributes to a human, agent, or service identity.

    Every action maps to exactly one of the three classes above — including agents acting under delegation, which use their own non-human identities, never borrowed human ones.

  3. All human and agent access is logged and monitored.

    Services run statically verifiable code at high volume, so we lean on CI/CD controls there. Humans and agents are less predictable — their access gets verbose logs and continuous monitoring.

  4. Humans and agents have zero standing privileges.

    All access is continuously authorized at access-time, based on the action attempted and the work assignment it links to. Over time, tasks will require second-person assignment to further lower the odds of rogue action.

  5. Services run only trusted code in production.

    Binary authorization enforces that production code is signed and trusted, with the bar for trusted rising over time — supply-chain controls included — until internal and external code alike is carefully checked.

  6. Outside documented access pathways, data is encrypted and inaccessible.

    Encryption enforces the boundary. No one circumvents controls by reaching lower in the stack — at rest, in transit, and eventually everywhere outside our documented administrative access points.

dynax://demo — request access

See your access snapshot.

Thirty minutes, your systems (or our sandbox), and the first honest answer to "who can do what?" your organization has ever had.