Public documentation for governed AI labor
SDKs/Governance/Connectors
Arx / Docs / ARX + NOMA: AI Agent Governance and Observability Integration

Documentation

ARX + NOMA: AI Agent Governance and Observability Integration

arxsec-site / NOMA_INTEGRATION_BRIEF.md

arxsec-site market NOMA_INTEGRATION_BRIEF.md

Executive Summary

ARX and NOMA form a complete governance and observability stack for AI agents in production. NOMA provides real-time visibility into agent behavior, decision traces, and resource consumption. ARX enforces security policies at the moment of action, gates high-risk decisions with approval workflows, and maintains immutable audit trails. Together, they enable organizations to deploy governed agents that are both transparent and compliant.

---

The Problem

Organizations deploying AI agents face a critical gap: visibility without control, or control without visibility.

  • Observability-only approach (NOMA alone): You can see what your agents are doing—token usage, latency, decision paths—but you cannot enforce policies or require approvals at runtime. By the time you detect a problem in traces, the agent has already acted.
  • Governance-only approach (ARX alone): You can enforce policies and gate decisions, but you lack the detailed observability needed to understand *why* decisions were made or to correlate agent behavior with business outcomes.

ARX + NOMA bridges this gap.

---

How They Work Together

NOMA (Observability)

NOMA captures comprehensive runtime data for every agent execution:

  • Decision traces: Complete chain of reasoning, tool calls, and LLM responses
  • Token metrics: Input/output token counts, cost per invocation, cumulative spend
  • Latency and performance: End-to-end execution time, per-step timing, bottleneck detection
  • State snapshots: Agent memory, context, and intermediate results at each step
  • Tool execution logs: Which tools were called, arguments, results, and execution time

ARX (Governance)

ARX sits at the execution boundary and enforces policies:

  • Pre-execution policy checks: Blocks unauthorized tool calls before they reach external systems
  • Risk classification: Each connector operation tagged as LOW, MEDIUM, HIGH, or CRITICAL
  • Approval gates: HIGH and CRITICAL operations wait for human review (Slack, email, ITSM)
  • Audit logging: Every decision, approval, denial, and action logged immutably
  • Connector-aware governance: Policy written per-connector, per-operation (e.g., okta:users:delete vs. okta:users:read)

---

Integration Architecture

`` ┌─────────────────────────────────────────────────────────┐ │ Agent Application │ │ (LangChain, CrewAI, or custom framework) │ └──────────────────────────────────────────────────────────┘ │ ┌──────▼──────┐ │ ARX Client │ │ (SDK) │ └──────┬──────┘ │ ┌──────────────────┼──────────────────┐ │ │ │ ┌────▼────┐ ┌──────▼──────┐ ┌─────▼──────┐ │ Policy │ │ Approvals │ │ Audit │ │ Engine │ │ (Slack, │ │ Logging │ │ │ │ Email) │ │ (Events) │ └────┬────┘ └──────┬──────┘ └─────┬──────┘ │ │ │ └──────────────────┼─────────────────┘ │ ┌──────▼──────┐ │ Connectors │ │ (External │ │ APIs) │ └─────────────┘ │ ┌──────────────────┼──────────────────┐ │ │ │ ┌────▼────┐ ┌──────▼──────┐ ┌─────▼──────┐ │Okta │ │ Datadog │ │ AWS │ │(users) │ │(dashboards) │ │(resources) │ └─────────┘ └─────────────┘ └────────────┘ │ │ (correlation ID) │ ┌────▼──────────────────────────────┐ │ NOMA Trace Annotation │ │ - Decision point logged by ARX │ │ - Approval metadata injected │ │ - Full decision trail visible │ └───────────────────────────────────┘ ``

---

Workflow Example: Automated Access Review

Scenario

An ARX-governed agent audits user access in Okta (identity management). The agent has a policy that:

  • okta:users:read operations are LOW-risk → autonomous, no approval needed
  • okta:users:deactivate operations are HIGH-risk → require manager approval before execution

Step-by-Step

1. Agent decides to deactivate a user ```python

Agent calls ARX

result = await arx_client.execute( connector="okta", operation="users:deactivate", params={"user_id": "user@example.com"} ) ```

2. ARX evaluates policy

  • Policy engine checks: operation is users:deactivate → HIGH risk
  • Decision: requires approval
  • ARX does NOT execute the Okta API call yet

3. ARX routes for approval

  • Approval workflow triggered
  • Slack message sent to #access-reviews with context:
  • Agent name, operation, user affected
  • Risk level, reason (from agent's reasoning trace)
  • Approve/Deny buttons
  • Agent execution pauses, waiting for human decision

4. Approver reviews and decides

  • Manager clicks "Approve" in Slack
  • ARX records: approver ID, timestamp, approval reason
  • ARX now executes the Okta API call
  • Returns result to agent

5. Unified audit trail (NOMA integration)

  • NOMA captures the full agent trace:
  • Agent's reasoning for the deactivation
  • LLM outputs, tool calls, decision checkpoints
  • ARX emits audit event:
  • Operation: okta:users:deactivate
  • Status: approved
  • Approver: manager@example.com
  • Decision timestamp
  • Policy applied: okta-access-review
  • NOMA annotates its trace with ARX approval metadata
  • Final trace in NOMA shows:
  • Agent decision → ARX gate → manager approval → execution → Okta result
  • All timestamps aligned
  • Full decision chain visible for audits

6. Real-time dashboard

  • NOMA dashboard shows agent execution with approval annotations
  • Approval SLA timer visible (e.g., "Approved in 2min 15sec")
  • ARX audit events streamed to Redis → dashboards show approval rates, denial patterns
  • Compliance report generated: "All deactivations were approved before execution"

---

Key Integration Points

1. Execution Flow

ARX intercepts agent tool calls *before* they reach external APIs. This allows:

  • Policy evaluation in real-time
  • Approval gating without modifying agent code
  • No retry loops or failed executions

2. Trace Correlation

ARX provides a correlation ID for every policy decision:

  • Agent includes correlation ID in NOMA traces
  • ARX audit events tagged with same correlation ID
  • NOMA dashboard links agent trace to ARX decision
  • Auditors can trace any action back to the approval that enabled it

3. Approval Context

When ARX routes for approval, it includes:

  • Agent name and version
  • Tool/operation being called
  • Agent's reasoning (optional, extracted from traces)
  • Risk classification and policy rationale
  • Approval deadline (configurable SLA)

Approvers can inspect the agent's decision trace in NOMA to understand *why* the action was recommended.

4. Event Streaming

ARX audit events (policy evaluations, approvals, denials) stream to:

  • NOMA: Annotates traces with governance decisions
  • Redis: Real-time event stream for dashboards and alerting
  • SIEM/Compliance: Immutable audit records for SOC2, HIPAA, SOX
  • Webhooks: Custom integrations (Slack notifications, PagerDuty incidents)

---

Data Flow: A Complete Picture

`` ┌──────────────────────────────────────────────────────────────────┐ │ Agent Execution │ │ │ │ 1. LLM decides: "Deactivate user john@acme.com in Okta" │ │ 2. Agent calls: arx.execute(connector="okta", op="deactivate") │ └────────────────────────┬─────────────────────────────────────────┘ │ │ Correlation ID: uuid-12345 │ ┌────────────────────▼──────────────────────┐ │ ARX Policy Engine │ │ │ │ Policy: okta-access-review │ │ Operation: okta:users:deactivate │ │ Risk: HIGH │ │ Decision: Approve Required │ └────────────────┬───────────────────────────┘ │ │ Emit: decision.required (uuid-12345) │ ┌────────────────▼──────────────────────┐ │ ARX Approvals │ │ Route: Slack #access-reviews │ │ TTL: 1 hour │ │ Status: pending │ └────────────────┬───────────────────────┘ │ ┌────────────────▼────────────────────────────────────────┐ │ NOMA Trace (Still Recording) │ │ │ │ Trace ID: trace-99999 │ │ Agent reasoning: "High risk user, needs review" │ │ Checkpoint: awaiting_approval (uuid-12345) │ │ Status: paused │ └────────────────┬───────────────────────────────────────┘ │ (Manager approves in Slack) │ ┌────────────────▼──────────────────────┐ │ ARX Approval Decision │ │ │ │ Approval ID: approval-77777 │ │ Approver: manager@example.com │ │ Decision: approved │ │ Timestamp: 2026-04-24T10:15:30Z │ │ Reason: "Verified with HRIS" │ └────────────────┬───────────────────────┘ │ │ Emit: decision.approved (uuid-12345) │ ┌────────────────▼──────────────────────────────────────────┐ │ ARX Execute (Resume Agent) │ │ │ │ API Call: POST /api/v1/users/{userId}/lifecycle/deactivate │ Auth: Bearer token (vault-sourced) │ │ Result: HTTP 204 OK │ │ Latency: 234ms │ └────────────────┬───────────────────────────────────────────┘ │ │ Emit: operation.executed (uuid-12345) │ ┌────────────────▼──────────────────────────────────────────┐ │ NOMA Resume Trace │ │ │ │ Checkpoint: resumed │ │ Approval metadata injected: │ │ - approval_id: approval-77777 │ │ - approver: manager@example.com │ │ - approval_timestamp: 2026-04-24T10:15:30Z │ │ Okta response logged │ │ Agent continues... │ └────────────────┬───────────────────────────────────────────┘ │ ┌────────────────▼──────────────────────────────────────────┐ │ Unified Audit Trail Available │ │ │ │ Query: "Show all user deactivations with approvals" │ │ Results (NOMA dashboard): │ │ - Trace ID: trace-99999 │ │ - Operation: okta:users:deactivate │ │ - Risk: HIGH │ │ - Policy: okta-access-review │ │ - Approval: ✓ approved by manager@example.com │ │ - Latency: 234ms │ │ - Timestamp: 2026-04-24T10:15:30Z │ │ - Reason (from agent): "High risk user" │ │ │ │ Compliance Report: Ready for SOC2 audit │ └────────────────────────────────────────────────────────────┘ ``

---

Use Cases

1. Compliance Auditing

  • Problem: Auditors need to prove that high-risk actions were approved before execution
  • Solution: NOMA + ARX provides complete approval chain; correlation IDs link agent reasoning to governance decisions
  • Outcome: "All 47 user deactivations in Q1 were approved before execution. Approval SLA: 100% within 1 hour."

2. Cost Control

  • Problem: Agents can make expensive API calls (e.g., bulk data exports, large model inferences) without oversight
  • Solution: ARX gates expensive operations; NOMA tracks cost per agent invocation
  • Outcome: Dashboard shows which agents trigger approvals most; cost trends aligned with approval decisions

3. Operational Incident Response

  • Problem: An agent misbehaves (e.g., makes unintended API calls). You need to understand what happened and why
  • Solution: NOMA trace shows agent's reasoning; ARX audit shows which operations succeeded or were blocked
  • Outcome: "Agent tried to deactivate 15 users; 3 were blocked by policy, 12 were approved by manager, 0 failed"

4. Rollout Safety

  • Problem: New agent version may have unexpected behavior in production
  • Solution: Deploy with HIGH approval requirements; NOMA traces capture decision patterns; ARX approvals force human review during rollout
  • Outcome: "New agent approved for 100% of operations in week 1; scaled to 80% autonomous in week 2 after approval patterns stabilized"

---

Configuration Example

ARX Policy (Okta Access Review)

```yaml

  • name: okta-access-review

connector: okta operations:

  • "users:read*" # LOW-risk: autonomous
  • "groups:read*" # LOW-risk: autonomous
  • "users:create" # MEDIUM-risk: auto-approved (audit-logged)
  • "users:update" # MEDIUM-risk: auto-approved
  • "users:deactivate" # HIGH-risk: human approval required
  • "users:suspend" # HIGH-risk: human approval required
  • "users:reset_password" # HIGH-risk: human approval required

risk_max: high approval: medium: auto high: hitl hitl_channel: "#access-reviews" hitl_timeout: 1h ```

NOMA Integration (SDK)

```python from noma import NOMAClient from arx import ARXClient

noma = NOMAClient(api_key="noma-key") arx = ARXClient(agent_id="agent-access-reviewer", org_id="acme-corp")

async def audit_user_access(): trace_id = noma.start_trace("audit_user_access") correlation_id = str(uuid.uuid4())

Policy evaluation happens transparently

users = await arx.execute( connector="okta", operation="users:read", params={"filter": "status=ACTIVE"}, correlation_id=correlation_id # Links ARX decision to NOMA trace )

for user in users: if is_risky(user):

This call will pause for approval

result = await arx.execute( connector="okta", operation="users:deactivate", params={"user_id": user.id}, correlation_id=correlation_id # Same trace )

noma.log_checkpoint( trace_id=trace_id, name="user_deactivated", metadata={ "user_id": user.id, "correlation_id": correlation_id, "approval": result.approval_metadata # Injected by ARX } )

noma.end_trace(trace_id) ```

---

Benefits

| Benefit | Enabled By | Impact | |---------|-----------|--------| | Real-time policy enforcement | ARX gates decisions before execution | 0 unauthorized API calls reach external systems | | Approval transparency | Correlation IDs link decisions to traces | Auditors see *why* each action was approved | | Cost visibility | NOMA metrics + ARX operation counts | Track spend per agent, per policy, per approver | | Incident forensics | Complete trace + audit log correlation | Root cause analysis: agent reasoning + governance decisions | | Compliance automation | Immutable audit trail with approval chain | SOC2, HIPAA, SOX reports auto-generated | | Approval SLA tracking | ARX timestamps + NOMA latency metrics | Optimize approval workflows based on data | | Safe rollouts | High approval requirements during rollout | Gradual autonomous scaling with data-driven gates |

---

Getting Started

  1. Deploy ARX SDK in your agent application (LangChain, CrewAI, or custom)
  2. Define policies for sensitive connectors (Okta, AWS, Datadog, etc.)
  3. Configure NOMA to capture agent traces
  4. Pass correlation IDs from agent to ARX to NOMA for trace linking
  5. Set up approval channels (Slack, email, custom ITSM)
  6. Monitor dashboards (ARX audit metrics + NOMA traces side-by-side)

---

Conclusion

ARX + NOMA turn AI agent deployments from a "trust and hope" model to a "verify and control" model. NOMA shows you what your agents are thinking; ARX ensures they don't act without approval. Together, they provide the governance, observability, and auditability that enterprises demand from AI systems.