In our last policy engineering post, we showed ArmorIQ’s policy compiler in action. The core idea was simple: policy should be grounded in the agent’s actual tools and schemas, compiled into deterministic semantics, checked before deployment, and enforced consistently across runtimes. That solved the bottom half of the problem. But someone still had to write the policy.
Our long-term vision is that this should eventually disappear too. A user should express what they want an agent to accomplish. The organization already has boundaries. The system already knows which agents, tools, identities, and environments exist. Policy should increasingly be derived from that context instead of written from scratch.
The new demo moves one step closer to that future.
Start with the agent that actually exists
The demo begins with a healthcare claims agent exposing 22 tools. Instead of presenting the user with an empty policy editor, ArmorIQ starts from the real agent. The builder can inspect its tools, understand their descriptions and schemas, and answer questions such as:
Which of these tools can change data?
That changes the starting point for policy authoring. Traditional policy systems ask humans to describe the environment manually. Here, the environment is already known. The user only needs to describe the boundary they care about.
The builder might identify claim submission, claim deletion, payment determination, and similar operations as consequential. From there, the operator can start shaping what the agent should be allowed to do. The policy begins with reality, not with a blank file.
Let AI propose. Do not let it decide authority.
Natural-language policy immediately introduces a harder problem: humans are imprecise. Suppose the user says:
Only trusted people should be able to submit or delete claims.
“Trusted people” sounds perfectly reasonable. It is also unusable as an enforceable identity rule. Does trusted mean administrators? A particular team? Named people? Anyone with an existing privileged role?
A model could guess. ArmorIQ does not. The builder asks the user to clarify. That distinction matters because once AI participates in security policy, model confidence cannot quietly become authorization. The builder can interpret intent, inspect context, and propose structure. But when the request is ambiguous in a way that affects authority, the uncertainty should return to the human.
This is the same principle we use elsewhere in ArmorIQ: generation can remain probabilistic, but the boundary around authority should become deterministic.
Natural language should create precise, narrow changes
The demo then moves to a much more specific request:
Reading claims is fine. Allow clean-claim submissions up to $10,000, hold anything above $10,000 for an org admin, and block claim deletion.
This is where conversational policy becomes genuinely useful. ArmorIQ can turn that request into structured rules over the real claim tools and their arguments. The threshold is no longer prose. The approval path is no longer implied. The deletion boundary becomes explicit.
But the builder does something equally important: it leaves unrelated policy alone. If the user changes one approval threshold, the system should not regenerate the organization’s entire authority model. That is an important difference between editing prose and editing policy.
A generative model rewriting an essay can improve every paragraph along the way. A generative model rewriting security policy can accidentally change authority that nobody asked it to touch. So small requests should produce small deltas. Conversational policy only becomes safe when the scope of the conversation constrains the scope of the change.
Every generated rule should have provenance
There is another problem with AI-generated policy: where did the rule come from?
If the builder creates a deny rule, approval condition, or threshold, the organization needs more than “the model generated it.” The demo keeps the generated policy tied back to the language that justified it. The $10,000 threshold came from the user. The delete restriction came from the user. The human approval requirement came from the user.
That lineage matters because generating policy is cheap. Changing authority is not.
If a rule cannot be justified by the user’s request, existing organizational policy, or trusted context, the system should not quietly invent it. This gives AI-assisted policy construction an important property: generated rules remain explainable in human terms.
The builder sits above the compiler
The most important architectural point in the demo is what happens next. The builder does not directly become the policy engine. It produces a candidate policy. That candidate still goes through the deterministic compiler from our previous demo. This separation is deliberate. The builder answers:
What policy seems to represent what the human asked for?
The compiler answers:
Is this policy valid against the agent’s real tools and schemas, and can the system actually enforce it?
Those are different questions. If the builder references something invalid, the compiler catches it. If a condition does not match the real schema of a tool, compilation fails. The draft can then be repaired and checked again. The AI generating the policy does not get to certify its own work. That is the trust boundary.
The path is therefore not simply natural language → AI → enforcement. It is human requirement → AI-assisted proposal → deterministic compilation → human review → enforcement. That is a much safer way to bring generative AI into the policy loop.
Policy should speak the language of the organization
The second half of the demo brings identities into the same interaction. Policies are not just about which tool can run. They are also about who may cause a consequential action.
The builder can resolve real organizational members and let the user express rules in ordinary organizational language. A specific person may approve a high-value claim. Another member may have a lower independent submission limit. Everyone else may inherit the organization-wide default.
The operator does not need to know how those identities are represented internally. They speak in the vocabulary they already use. ArmorIQ translates that into enforceable structure.
This is where the builder becomes more than a natural-language wrapper around a policy file. It begins connecting the user’s language to the organization’s real capability and identity graph.
But the human is still writing the policy
This is where we should be precise about what the demo does not yet solve. A human still has to say:
Allow this.
Block that.
Require approval above this threshold.
The interface is dramatically easier than hand-writing policy. The system knows the tools. It knows the schemas. It knows the organization. It can ask questions when something is unclear, preserve unrelated decisions, maintain provenance, and verify the result through the compiler.
But the human is still authoring policy. They are simply authoring it conversationally. Our end state is further away.
The next step is to stop starting from a blank conversation
Imagine ArmorIQ also knows what this claims agent has actually done over the last month.
Perhaps it has read claims thousands of times. Clean claims below a certain value are routinely submitted without incident. Large claims consistently involve human approval. Claim deletion exists as a capability but has never been part of a legitimate workflow. Now combine that history with the live tool inventory, organizational roles, existing policies, and the purpose of the agent. The conversation can change.
Instead of asking:
What rules would you like to create?
the system can begin with:
This is the authority the agent appears to use. These operations look routine. These actions are exceptional. This capability exists but has never been legitimately exercised. Here are the boundaries already implied by your organization.
At that point, the human is no longer primarily writing policy. They are reviewing a proposed authority model. That is the direction of the next step.
The current builder combines human intent with live system context. The next version can add historical execution evidence. Eventually, purpose gives us another dimension: not only what the agent has done, but whether that behavior was justified by what the agent was supposed to accomplish. That is how policy begins shifting from authored configuration toward derived authority.
The middle keeps getting smaller
Our first policy demo started with an explicitly written policy and showed that ArmorIQ could compile it into reliable enforcement.
This demo moves one level higher. A person can describe the desired boundary conversationally, while ArmorIQ grounds it in real tools, schemas, identities, and existing policy. Ambiguity returns to the human. Changes remain scoped. Generated rules retain provenance. The deterministic compiler still decides whether the result is structurally valid and enforceable. The next step moves higher again.
Instead of requiring the human to describe every boundary, the system can begin from the agent’s observed behavior and organizational context and propose what the policy should be.
The policy still exists. The compiler still matters. The enforcement system still requires deterministic semantics. What keeps shrinking is the amount humans have to author. That is the trajectory we are building toward at ArmorIQ: not an AI that writes policy files for people, but a system that understands enough about the organization, the agent, its capabilities, its history, and ultimately its purpose that policy becomes increasingly something the system can derive rather than something humans have to write.



