Access control & entitlements
On this page
"Can this person do this, to this, right now?" Modern access control answers that from attributes and policy rather than brittle, ever-growing lists of static roles, and that decision is itself a rule evaluation on the critical path of every request.
⚡ Where speed pays for itself
Authorization runs on every request. Even a few extra milliseconds, multiplied across billions of calls, is a speed tax on the whole product and a larger server bill. Winnow decides in microseconds, inside your own service: no per-request trip to a policy server, no fleet to scale, so the cost of enforcing access stays near zero however much traffic grows.
The stakes🔗
Access is where breaches happen. In Verizon's analysis, stolen credentials appear in ~38% of breaches and 68% involve a human element (Verizon DBIR 2024). Static role lists drift and over-grant over time. Attribute-based access control (ABAC) decides each request from the subject, the resource, and the context, which means an engine has to evaluate a policy, correctly and fast, on every call.
How it works🔗
A policy is a rule over the requester, the resource, and the context. For example, "allow when the user is in department 4, has clearance level 3 or higher, the resource is class 7, and the user is not a contractor." Rules can also compare one attribute against another (the level requested against the level granted, say). Every access request is evaluated against the policy, and the policy is editable as plain text.
🤖 With AI in the loop
AI agents have turned access control into a machine-speed problem: an agent doesn't just answer, it acts, and every tool call needs a permission decision. Amazon's Bedrock AgentCore Gateway checks each agent tool call against permit/forbid policies (who, what action, which resource, in what context) in under a millisecond, with policy changes deployed by API call. Microsoft 365 Copilot consults Purview rules on every prompt so labeled-sensitive content is excluded from what the AI may read or repeat. Glean filters everything its AI assistant retrieves through the asking user's live permissions. One user request can fan out into dozens of agent actions, so a policy check that costs milliseconds becomes the product's bottleneck; one that costs microseconds disappears. More patterns: Deep Dive: AI + Rules Engines.
Why Winnow fits🔗
- Attributes are first-class: department, role, and resource class are
category checks; clearance and limits are
number checks; conditions combine with
AND/OR/NOT; and a request's attributes can be compared directly against a resource's. - On the request path: microsecond decisions, made inside your own service, so there is no extra hop to a policy server before every action.
- Revoke and grant live: change a policy by editing rules; requests already in flight still see one complete, consistent policy, and nothing restarts.
- Both directions: check one request against many policies, or audit the whole population ("who can currently access resource class 7?") in one pass.
🧪 In simulation — 200,000 policies, 1 million access requests
To put numbers on the above, we built a policy book the way one actually accretes: 200,000 standing policies in six families — per-resource access lists, clearance gates that compare the level requested against the level granted, department entitlements, resource-class grants, and two families of explicit denies (after-hours and privilege caps) — then authorized 1 million requests against all of it, deny beating allow. 59% of requests were granted, 9% denied, and the rest matched no policy at all; on about 51,000 of them a deny overrode a grant some other policy had given.
What this is: a test run on a generated policy book and a generated request stream, not a customer deployment — the policies and traffic are invented, the speeds and costs are measured. It ran on one ordinary 16-core desktop computer, priced at a standard cloud rate of $0.043 per processor-hour running around the clock, the same basis as the Deep Dive: Cost Savings. Every verdict was double-checked against a slow, exhaustive pass over all 200,000 policies before any stopwatch started — that slow way takes about 12 times longer — so no grant or deny comes from a policy quietly skipped. Treat the speeds as approximate, moving by about a fifth with machine load, and the counts as exact; the test ships with Winnow for your team to re-run on your own policies.