ARMORIQ

When Agent Control Begins with an Agent

Meet Inty, it helps you understand your agent environment and soon allow you full control if you stay tuned.

Nov 21, 20269 min read
When Agent Control Begins with an Agent// Cover

The road to Inty

A human request can become a surprisingly complex system. An agent develops a plan, discovers tools, delegates work, and changes its approach as new information arrives. The original objective may eventually span several agents, applications, and execution environments. Through those changes, the authority behind the work needs continuity.

That has been the thread connecting our earlier ArmorIQ posts. In our writing on intent, we argued that purpose should remain intact as plans evolve. An agent can discover a better approach without acquiring broader authority simply because that approach would be useful. Delegation needs the same discipline.

Authority must travel

The Intent Container series followed that principle into infrastructure. From Objective to Syscall and Execution State Can Travel Backward. Authority Cannot. The objective needs a continuing identity, authority, and lifecycle, even as the agents carrying it out change.

Control needs an interface

Our policy compilation work then explored how objectives, organizational boundaries, and the live environment can become inputs to enforceable controls. It also creates a practical requirement: people need a way to understand and operate the resulting control fabric.

They need to see what agents are doing, which decisions require attention, and what evidence supports those decisions.

Inty begins bringing that interface into the ArmorIQ workspace.

Inside the demo

We are sharing a sneak preview of Inty answering questions about live workspace information, within the user’s permissions.

Inty is read-only in this recording. ArmorIQ’s existing control fabric governs the demonstrated agent actions, and the user handles approval through the platform. The experience of operating those controls through Inty is still to come.

The demo follows a complete operating sequence: understand the workspace, examine a held payment, review a different policy outcome, compare agents, identify administrators, and explore the connections across the agent environment.

Start with the workspace

The demonstration begins with a straightforward operational question:

How many tool calls were allowed, held, and denied in the last 30 days?

Inty returns the demo workspace’s reported activity: 235 allowed, 51 held, and 51 denied. This establishes the operating picture before we examine an individual action. Inty makes that picture accessible through a question asked alongside the dashboard.

The next sequence moves from understanding those outcomes to following one as it happens.

Follow a held payment

An accounts payable agent receives a request to record a $6,000 payment. The instruction says the details are verified and tells the agent to proceed without asking for confirmation.

The agent prepares a record_payment call. ArmorIQ holds it for approval. The prompt asks for immediate execution, but the approval boundary remains in force. The attempted action appears in ArmorIQ’s held-action workflow, where the reviewer can inspect it.

Inty is available at that decision point. The reviewer asks why the action was held. Inty surfaces the information in the request: an amount of 6,000, a requester limit of zero, and no recorded decision note. The answer gives the reviewer concrete context while keeping the explanation grounded in the visible record.

Keep the decision accountable

The conversation continues with another question: what is the newest held action, and who must approve it? Inty identifies the pending $6,000 request. It also states that no specific approver is listed in the details it can see. That qualification matters. The assistant can identify the request and explain its recorded state without inventing an approval route. The video then shows the operator approving through ArmorIQ’s controls. The decision is recorded.

Inty supports the reviewer’s understanding.

See a different boundary

The same accounts payable agent is then asked to record a $60,000 payment. This time, ArmorIQ blocks the tool call under the demonstrated policy. The two examples show distinct control outcomes. The $6,000 request enters human review. The $60,000 request is denied.

Together, they make the control fabric visible in operation: a request becomes a proposed tool call, and that call encounters the authority governing its execution. Inty helps people understand the surrounding context. ArmorIQ provides the enforcement.

Compare the agents

The demo then broadens from one transaction to the agent environment. The user asks which agent is most vulnerable and which has the most held plans. Inty reports both ties: two agents have three recorded vulnerabilities each, while the held-plan comparison finds two agents with fourteen held plans each.

The answer gives the user a starting point for further investigation while preserving what the comparison actually establishes.

Ask about the team

Next, the demonstration moves into the administrative workspace. An administrator asks who the workspace admins are. Inty answers from the available member records. This extends the conversation from agent activity to the people operating the environment. The assistant uses the context accessible to the user’s role.

Inty’s visibility follows the user’s access.

Explore the graph

The final major sequence opens the AIQ Graph. The user selects the accounts payable agent and asks what it can reach. Inty explains its connections to two MCP servers and describes the tool paths associated with them, including payment, invoice, and financial-reporting operations. It also makes an important qualification: the graph shows connections, which do not establish whether the agent can currently execute those calls. A visible path and executable authority are different pieces of information.

Inty brings the connections, status, and governing context into the same explanation. The user can then continue the conversation from that answer and investigate further.

Inty is governed too

Inty itself is governed by ArmorIQ.

Its access to workspace information operates within the user’s permissions and ArmorIQ’s controls. Inty participates in the governed environment it helps people understand.

As control capabilities are introduced, Inty will operate through the same control fabric governing the agents it helps manage. Human delegation and organizational policy remain the basis of its authority.

“One agent controlling all agents” includes governance of the controlling agent itself.

The interface can become more intelligent while the authority governing its actions remains explicit and independently enforced.

Full control comes next

In the next version, we will show “One agent controlling all agents” through the ArmorIQ control fabric.

This connects to what we have been doing at ArmorIQ. Purpose needs continuity through changing plans. Delegation needs bounded authority. Objectives need a lifecycle that survives individual agents. The relationships among objectives need governance too.

Inty simply brings it to life through a conversational interface.

Its intelligence can help interpret a request and identify a course of action. The fabric governs which actions may proceed. The sneak preview demos understanding: reading the environment, explaining records, and helping people inspect decisions. Stay tuned for the full experience of operating those controls through Inty.

The ecosystem is moving

Agent control is becoming part of the infrastructure around autonomous work. AWS AgentCore places deterministic policy enforcement at the tool gateway, outside agent code. Microsoft Entra Agent ID gives agents dedicated identities and structures for managing their access. NVIDIA OpenShell defines enforceable filesystem and network boundaries around the runtime.

These efforts address different layers of a common problem: giving agents useful capabilities while retaining authority over their effects. We read them as signs of a broader architectural shift. Control is becoming something the agent stack must provide.

That direction deserves attention beyond any single product. The choices made now about identity, delegation, policy, and execution will shape how easily organizations can adopt more capable agents later. The opportunity is to build a coherent foundation while the environment is still taking shape.

For enterprise and security leaders

If you are an enterprise buyer or security leader, this is the moment to think about the operating model for autonomous work.

  • Every additional agent introduces relationships among identities, tools, data, and owners. Those relationships become harder to govern coherently when each deployment establishes its own assumptions about authority.

  • The advantage we see is the ability to adopt useful autonomy without repeatedly rebuilding its governance. Organizations that establish a common control foundation early can preserve more freedom to choose models, tools, and platforms as the ecosystem evolves.

The decisions made around authority today will shape how much responsibility an organization can delegate tomorrow.

For developers and builders

If you are a developer or builder, the direction is toward agents that can participate in a governed ecosystem.

  • Capability will remain essential. So will the ability to connect an agent to the identities, permissions, policies, and operating practices around it.

  • We expect agents built with these relationships in mind to be easier to integrate and operate as the ecosystem develops. Clear authority boundaries and usable evidence can become part of what makes an agent deployable across different environments.

  • Making those choices early preserves options that become harder to recover after permissions and workflows have spread across the stack.

Build for the environment agents are entering, including the systems that will govern their work.

For investors

If you are an investor, the direction worth examining is the infrastructure being assembled around agent capability.

  • Identity, authorization, runtime enforcement, orchestration, and evidence each address part of how autonomous work becomes operational. Their connections matter increasingly as one objective spans several agents and systems.

  • Our thesis is that increasing agent capability creates a corresponding need for infrastructure that makes delegation manageable and accountable. That opportunity extends across the ecosystem.

  • This is a useful moment to look beyond individual demonstrations and consider the dependencies organizations will develop as they entrust agents with more consequential work.

The operating architecture around agents is taking shape now. Understanding that architecture may matter as much as understanding the agents themselves.

The next chapter

Inty is our step in that direction. This sneak preview begins with understanding: reading the governed environment, explaining decisions, and making the available evidence accessible through conversation.

In the next version, we will show how that interface becomes a way to control the agents connected through ArmorIQ with Inty itself governed by the same fabric. The broader opportunity reaches beyond that demonstration. As autonomous work expands, the ecosystem needs practical ways to preserve human authority across it.

The architectural choices being made now will shape what organizations can confidently delegate next.

Onboarding open

Ready to control what your AI agents actually do?

Join the teams shipping safer, compliant AI agent deployments. White-glove onboarding for the first 50 design partners.

Read Docs →
Live Intent Assurance↗