DEV Community: Srirajasekhar Koritala

Govern Any AI Agent in 5 Minutes: A Technical Guide

Srirajasekhar Koritala — Tue, 03 Mar 2026 16:53:39 +0000

Unlock Enterprise AI Automation in 5 Minutes

Your team is using AI agents — OpenClaw, Claude Code, LangChain, custom tools. They're automating incredible things: writing code, managing infrastructure, processing data, driving workflows.

The capability is real. Now make it enterprise-ready.

This guide shows you how to connect any AI agent to the AICtrlNet Runtime Gateway in 5 minutes — so your team keeps the automation power, and your enterprise gets the visibility, control, and audit trails it needs to say yes.

What You'll Get

After completing this guide, your AI agents are enterprise-ready:

Every agent action is evaluated before execution
Risk scores (0.0-1.0) prioritize what needs human attention
ALLOW/DENY/ESCALATE decisions — AI keeps moving, governance runs inline
Complete audit trail — the answer to every compliance question
One-click suspend — immediate control when you need it

The result: your team automates faster because governance removes the objections that block deployment.

Prerequisites

An autonomous AI agent running (OpenClaw, Claude Code, custom agent — any of them)
Python 3.9+
An AICtrlNet account (free trial works)

Step 1: Install the SDK (30 seconds)

pip install aictrlnet-runtime-sdk

Step 2: Get Your API Credentials (60 seconds)

Log into hitlai.net
Navigate to Settings → API Keys
Click Create API Key
Copy the key (you won't see it again)

Set it as an environment variable:

export AICTRLNET_API_KEY="your-api-key-here"
export AICTRLNET_API_URL="https://api.aictrlnet.com"

Step 3: Register Your Agent (60 seconds)

Create a file called register_agent.py:

import asyncio
from aictrlnet_runtime_sdk import (
    AsyncAICtrlNetClient,
    RuntimeRegistrationRequest,
    AICtrlNetConfig
)

async def main():
    config = AICtrlNetConfig.from_env()
    client = AsyncAICtrlNetClient(config)

    # Register your agent — works with any type
    registration = await client.register(RuntimeRegistrationRequest(
        runtime_type="openclaw",  # or "claude_code", "cursor", "langchain", "custom"
        instance_name="my-dev-machine",
        metadata={
            "owner": "engineering-team",
            "environment": "development"
        }
    ))

    print(f"Registered! Runtime ID: {registration.runtime_id}")

    with open(".aictrlnet_runtime_id", "w") as f:
        f.write(registration.runtime_id)

asyncio.run(main())

Run it:

python register_agent.py
# Registered! Runtime ID: rt_abc123...

The runtime_type tells the gateway what kind of agent it's governing — but the governance pipeline is the same regardless. ALLOW/DENY/ESCALATE works identically whether the action came from OpenClaw or your custom Python script.

Step 4: Wrap Agent Actions with Governance (120 seconds)

This is the key part. Wrap your agent's action execution with the governance gateway.

Create governed_agent.py:

import asyncio
from aictrlnet_runtime_sdk import (
    AsyncAICtrlNetClient,
    GovernanceGateway,
    AICtrlNetConfig
)

async def main():
    config = AICtrlNetConfig.from_env()
    client = AsyncAICtrlNetClient(config)

    with open(".aictrlnet_runtime_id") as f:
        runtime_id = f.read().strip()

    # Create governance gateway
    gateway = GovernanceGateway(
        client=client,
        runtime_id=runtime_id
    )

    # Your actual execution logic (whatever your agent does)
    async def execute_command(cmd: str) -> str:
        import subprocess
        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
        return result.stdout

    # Wrap with governance — every call now gets evaluated
    governed_execute = gateway.wrap(
        action_type="shell_command",
        func=execute_command
    )

    # This command will be evaluated BEFORE execution
    try:
        result = await governed_execute("ls -la /tmp")
        print(f"Result: {result}")
    except gateway.ActionDenied as e:
        print(f"Denied: {e.reason}")
    except gateway.ActionEscalated as e:
        print(f"Needs approval: {e.approval_url}")

asyncio.run(main())

That's it. Every action your agent takes now passes through the Runtime Gateway before executing.

Step 5: View in Dashboard (30 seconds)

Go to hitlai.net and open the Runtime Gateway
You'll see your registered agent instance
Click on it to see:
- All actions evaluated
- Risk scores
- Decisions (ALLOW / DENY / ESCALATE)
- Full audit trail

What Just Happened

  Agent wants to run: ls -la /tmp
                │
                ▼
  ┌─────────────────────────────────┐
  │   AICtrlNet Runtime Gateway     │
  │                                 │
  │   1. Receive action request     │
  │   2. Evaluate through pipeline  │
  │      (Quality, Governance,      │
  │       Security, Monitoring)     │
  │   3. Calculate risk score       │
  │   4. Apply policy               │
  │   5. Log to audit trail         │
  └─────────────────────────────────┘
                │
        ┌───────┼───────┐
        ▼       ▼       ▼
     ALLOW    DENY   ESCALATE
   (execute) (block) (route to
                      human)

This is tool-agnostic. The gateway doesn't know or care which agent generated the action. It evaluates the action itself — what it does, what it touches, what the risk level is.

Default Policies

Out of the box, the gateway uses sensible defaults:

Action Type	Default Policy
Read operations	ALLOW
Write to temp directories	ALLOW
Write elsewhere	ESCALATE
Network requests	ALLOW with logging
Destructive commands (rm, drop, delete)	ESCALATE
Credential access	DENY

Customize these in Settings → Governance Policies — per department, per team, per agent type, per risk level.

Scaling to Your Whole Team

Rolling this out to multiple developers or multiple agent types:

import asyncio
from aictrlnet_runtime_sdk import AsyncAICtrlNetClient, AICtrlNetConfig

async def register_team():
    config = AICtrlNetConfig.from_env()
    client = AsyncAICtrlNetClient(config)

    agents = [
        {"name": "alice-openclaw", "type": "openclaw", "owner": "alice@company.com"},
        {"name": "bob-claude-code", "type": "claude_code", "owner": "bob@company.com"},
        {"name": "carol-custom", "type": "custom", "owner": "carol@company.com"},
        {"name": "ci-langchain", "type": "langchain", "owner": "devops@company.com"},
    ]

    for agent in agents:
        reg = await client.register(RuntimeRegistrationRequest(
            runtime_type=agent["type"],
            instance_name=agent["name"],
            metadata={"owner": agent["owner"], "department": "engineering"}
        ))
        print(f"Registered {agent['name']}: {reg.runtime_id}")

asyncio.run(register_team())

Different agents, different owners, same governance pipeline. One dashboard to see everything.

Autonomy Levels per Department

The Runtime Gateway supports per-department autonomy policies:

Engineering: Near-full autonomy for dev environments, supervised for production
Legal: AI-assisted only — AI drafts, humans approve everything
Marketing: Full automation for content workflows, supervised for budget decisions
Support: Full automation for Tier 1 tickets, supervised for enterprise customers

Configure this in the dashboard or via the policy API. Each department gets the autonomy level that matches their risk tolerance.

Next Steps

Set up team policies — define what should ALLOW, DENY, or ESCALATE per team
Configure notifications — get Slack/email alerts for ESCALATE decisions
Enable ML risk scoring — let the system learn your patterns (Business tier)
Connect more agents — the same gateway works for every tool your team adopts
Explore three-layer reach — Platform adapters (10,000+ tools), self-extending agents (any API), browser automation (any web app)

About AICtrlNet

AICtrlNet is AI-powered universal automation with governance built in. Three layers of automation reach — 10,000+ tools through platform adapters, any API through self-extending agents, any web app through browser automation. Whether you're running OpenClaw, Claude Code, or custom agents, the Runtime Gateway gives you the governance that lets your enterprise say yes.

AI that automates anything. Governance for everything.

Start your free 14-day trial: hitlai.net/trial

Open Source: github.com/Bodaty/aictrlnet-community — Runtime Gateway, MIT licensed
Free Trial: hitlai.net/trial — 14 days, full governance features
Documentation: docs.aictrlnet.com

Questions? Open a discussion on GitHub or reach out to support@aictrlnet.com.

The OpenClaw Moment Has Evolved

Srirajasekhar Koritala — Tue, 03 Mar 2026 16:39:19 +0000

Something remarkable happened over the past few months. An Austrian engineer named Peter Steinberger built a hobby project called "Clawdbot" in November 2025. By late January 2026, it had evolved into OpenClaw — and amassed over 200,000 GitHub stars.

OpenClaw isn't just another chatbot. It has "hands." It can execute shell commands, manage local files, and navigate messaging platforms like WhatsApp and Slack with persistent, root-level permissions.

For the first time, autonomous AI agents have proven they can automate almost anything a developer can do. The capability is real. The productivity gains are extraordinary.

And now the question isn't whether AI agents can automate your work. It's how your enterprise harnesses that power responsibly.

The Adoption Explosion — and the Governance Gap

"It's not an isolated, rare thing; it's happening across almost every organization," says Pukar Hamal, CEO of SecurityPal. "There are companies finding engineers who have given OpenClaw access to their devices."

Cisco's AI Threat & Security Research team called OpenClaw "groundbreaking" from a capability perspective. The productivity gains are real — developers report 10x acceleration on routine tasks.

But here's the gap: employees are adopting AI automation faster than enterprises can govern it. No visibility into what agents are doing. No audit trails. No way for IT or security teams to know what's happening.

This isn't a reason to block AI agents. It's a reason to govern them — so your teams get the automation power they want, and your enterprise gets the visibility it needs.

Five Takeaways from the OpenClaw Moment

VentureBeat recently published an analysis of what this means for enterprises¹. Here's what stood out — and what it means for anyone building or deploying AI systems.

1. You Need Less Preparation Than You Think

The prevailing wisdom suggested enterprises needed massive infrastructure overhauls and perfectly curated data sets before AI could be useful. OpenClaw shattered that myth.

"There is a surprising insight there: you actually don't need to do too much preparation," says Tanmai Gopal, Co-founder & CEO at PromptQL. "Everybody thought we needed new software and new AI-native companies to come and do things. It will catalyze more disruption as leadership realizes that we don't actually need to prep so much to get AI to be productive."

Modern AI models can navigate messy, uncurated data by treating intelligence as a service. The barrier to entry just collapsed.

2. Governance Enables Adoption, Not the Opposite

Without governance, AI automation stalls at the pilot stage. Without audit trails, compliance blocks deployment. Without risk scoring, every action needs human review — defeating the purpose of automation.

Organizations like AUIC are already providing certification standards (AIUC-1) that enterprises can put agents through to obtain insurance coverage. Governance isn't a tax on AI automation — it's the permission slip that lets enterprises deploy it at scale.

3. The Security Model Is Broken

Itamar Golan, founder of Prompt Security, put it bluntly: "Treat agents as production infrastructure, not a productivity app: least privilege, scoped tokens, allowlisted actions, strong authentication on every integration, and auditability end-to-end."²

The old security model assumed humans were the actors. When AI agents become the actors — with persistent permissions and autonomous decision-making — everything changes.

4. SaaS Is Being Disrupted (Again)

The 2026 "SaaSpocalypse" saw massive value erased from software indices as investors realized agents could disrupt traditional SaaS models. If an agent can navigate any interface, why pay for specialized software?

The platforms that survive will be the ones that provide value agents can't replicate: governance, compliance, trust, and human oversight.

5. You Can't Stop Your Employees

Brianne Kimmel of Worklife Ventures frames this as a talent retention issue: "People are trying these on evenings and weekends, and it's hard for companies to ensure employees aren't trying the latest technologies."¹

Your best engineers will use the best tools. Blocking them doesn't work — they'll find workarounds or leave for companies that enable them.

The answer isn't blocking. It's governing.

What Enterprises Actually Need

Here's what the OpenClaw moment revealed about enterprise requirements:

Visibility: Know what agents are running, what they're doing, and what permissions they have.

Risk Scoring: Not all actions are equal. Deleting a test file is different from emailing a client. ML-powered risk assessment helps prioritize human attention.

Pre-Action Governance: Evaluate actions before they execute, not after. The difference between logging and governance is the difference between knowing what happened and preventing what shouldn't.

Audit Trails: When compliance asks "who approved this?" you need an answer. Every action, every decision, every override — documented.

The Control Spectrum: Not every department needs the same level of autonomy. Marketing might run at full speed while Legal stays fully supervised. One size doesn't fit all.

Suspend and Override: When something goes wrong, you need the ability to suspend an agent immediately — across your entire fleet if necessary.

The Path Forward

OpenClaw proved that AI can automate anything. The technology is here. The productivity gains are real. The genie isn't going back in the bottle.

The enterprises that thrive in the agentic era won't be the ones who block AI agents. They'll be the ones who govern them — and deploy them faster because of it.

They'll give employees the AI automation tools they want — with the visibility, risk management, and audit trails the organization needs.

They'll treat AI agents as production infrastructure, not toys.

And they'll recognize that governance isn't the brake on AI automation.

It's the accelerator — the thing that gets AI past compliance, past legal, past the CTO's desk, and into production.

About AICtrlNet

Whether you're running OpenClaw, Claude Code, LangChain agents, or custom autonomous systems, the Runtime Gateway evaluates every action before execution:

Pre-action evaluation: ALLOW, DENY, or ESCALATE every action
ML-powered risk scoring: Prioritize human attention where it matters
Fleet management: Visibility across all agents in your organization
Six phases of autonomy: From AI-assisted to fully autonomous — you choose
Suspend and override: Immediate control when you need it

AI that automates anything. Governance for everything.

Start with a free 14-day trial of the Business edition. The Community Edition is also available as open source.

Start your free trial: aictrlnet.com/openclaw

Bobby Koritala is the founder of AICtrlNet and holds multiple AI patents. He's spent 9 years building AI systems in healthcare, finance, and logistics.

References

VentureBeat. (2026). "What the OpenClaw moment means for enterprises: 5 big takeaways." venturebeat.com ↩
VentureBeat. (2026). "OpenClaw proves agentic AI works. It also proves your security model doesn't." venturebeat.com ↩

OpenAI Just Validated the Autonomous Agent Category — Here's What It Means

Srirajasekhar Koritala — Fri, 20 Feb 2026 19:36:17 +0000

Originally published on the AICtrlNet blog.

Two days ago, Peter Steinberger — the creator of OpenClaw, the fastest-growing open source project in GitHub history — joined OpenAI¹. Sam Altman personally recruited him. Mark Zuckerberg had already reached out via WhatsApp.

OpenClaw, which went from zero to over 200,000 stars in under three months², is transitioning to an independent open source foundation with OpenAI's backing. Steinberger's new role: driving "the next generation of personal agents."

This isn't just a talent acquisition. It's a signal — and a warning.

What OpenAI Is Really Saying

Sam Altman has been saying it for months: "The future is extremely multi-agent"¹. But hiring Steinberger makes it concrete. OpenAI isn't just building models — they're betting that autonomous agents, the kind that have root-level access to your machine and can execute shell commands, browse the web, and manage files on your behalf, are the next platform shift.

And they're right. The AI agent market is projected to grow from $7.8 billion in 2025 to $52.6 billion by 2030 — a 46.3% CAGR³. Gartner predicts 40% of enterprise applications will feature task-specific AI agents by end of 2026, up from less than 5% today⁴.

The agents are coming. The question is what comes next.

The Governance Gap Nobody's Closing

Here's the uncomfortable truth that the Steinberger hire exposes:

The industry is investing billions in making agents more capable. Almost nobody is investing in making them governable.

The numbers tell the story. Microsoft's Cyber Pulse report, published just five days before the Steinberger announcement, found that over 80% of Fortune 500 companies are already running active AI agents — but 29% of employees admit to using unsanctioned agents, and fewer than half of enterprises have implemented specific AI security safeguards⁵.

Gravitee's State of AI Agent Security survey made it even more concrete: only 14.4% of organizations report that all their AI agents go live with full security and IT approval. More than half of all agents operate without any security oversight or logging. And 88% of organizations have confirmed or suspected security incidents related to AI agents⁶.

Read that again: The vast majority of Fortune 500 companies have AI agents in production, and almost none of them have adequate governance in place.

This is Shadow AI at scale. And unlike Shadow IT — where the worst case was an unauthorized SaaS subscription — Shadow AI agents can read your codebase, send emails on your behalf, execute system commands, and access sensitive data. With root permissions.

The Market Already Knows This Is Real

Three days before Steinberger joined OpenAI, Proofpoint acquired Acuvity — a startup focused on AI security and governance for the "agentic workspace"⁷. The deal explicitly cited governance for tools like OpenClaw and MCP servers.

This wasn't a speculative acquisition. This was a major cybersecurity company saying: the governance market for autonomous agents is real, it's urgent, and it's big enough to acquire for.

And they're not alone. The Agentic AI Foundation (AAIF) recently formed under the Linux Foundation to provide vendor-neutral governance for MCP, A2A, and other agent protocols. When foundations start forming, it means the category is no longer experimental — it's infrastructure.

Why This Matters for Every Enterprise

Here's what the OpenClaw-to-OpenAI pipeline means in practice:

1. Autonomous agents are about to get corporate backing. OpenClaw was already the fastest-growing project in GitHub history as one developer's side project. Now it has OpenAI's resources behind it. Expect adoption to accelerate, not slow down.

2. "Block it" is not a strategy. As Worklife Ventures' Brianne Kimmel noted, employees are already "trying these on evenings and weekends, and it's hard for companies to ensure employees aren't trying the latest technologies"⁸. Blocking doesn't work — they'll find workarounds or leave for companies that let them move fast.

3. The security model needs to be rebuilt. As Prompt Security's Itamar Golan put it: "Treat agents as production infrastructure, not a productivity app: least privilege, scoped tokens, allowlisted actions, strong authentication on every integration, and auditability end-to-end"⁹.

4. Pre-action governance is the new standard. Logging what agents did after the fact isn't governance — it's forensics. Real governance means evaluating every action before it executes.

The Tool-Agnostic Imperative

Here's the thing most people miss: the governance challenge isn't OpenClaw-specific. OpenClaw is one tool. Claude Code is another. LangChain, CrewAI, AutoGen, Semantic Kernel — the frameworks are multiplying. Custom internal agents are proliferating even faster.

Any governance solution that's built for one tool is already obsolete. What enterprises need is a governance layer that sits between the agent and the action — regardless of which framework, model, or tool generated it.

That's the architecture we've been building at AICtrlNet since before OpenClaw went viral. Our Runtime Gateway evaluates every agent action through Quality, Governance, Security, and Monitoring dimensions, before execution. It doesn't care whether the action came from OpenClaw, Claude Code, a LangChain workflow, or a custom Python script.

This isn't a pitch deck. It's a shipping product:

171 conversation tools across 11 categories
29 adapters connecting AI frameworks, messaging platforms, databases, and compliance systems
183 workflow templates across 20+ industries
43 AI agents with graduated autonomy — our Control Spectrum defines 6 phases from "AI suggests, human decides" to full automation
6 messaging channels: Slack, Discord, Telegram, WhatsApp, SMS, Email
Self-extending agents that research, generate, and validate new integrations at runtime
Dry-run mode to test any workflow without side effects

The Community Edition is open source. The Business Edition is live with ML-enhanced risk scoring, fleet management, and our Done-With-You expert guidance model.

The Window Is Closing

If OpenAI is investing in making agents more autonomous, someone needs to invest in making them governable.

The enterprises that thrive in the agentic era won't be the ones who block AI agents or the ones who let them run unchecked. They'll be the ones who govern them — with visibility, risk management, audit trails, and human oversight built into the execution layer.

The window between "agents are useful" and "agents caused a compliance incident" is closing fast. The 88% incident rate in Gravitee's survey⁶ tells you it's already closing for most organizations.

OpenAI just placed their bet on the future of autonomous agents. The question for every enterprise is: who's placing the bet on governing them?

Ready to add governance to your AI agents?

Open Source: github.com/Bodaty/aictrlnet-community — Runtime Gateway, MIT licensed
Documentation: docs.aictrlnet.com
Enterprise Trial: hitlai.net/trial — 14 days, no credit card
The OpenClaw governance challenge: aictrlnet.com/openclaw

References

TechCrunch. (2026, February 15). "OpenClaw creator Peter Steinberger joins OpenAI." techcrunch.com ↩
Willison, S. (2026, February 15). "Three months of OpenClaw." simonwillison.net. OpenClaw's first commit was November 25, 2025; reached 200K+ stars by mid-February 2026, including 25,310 stars in a single day on January 26. ↩
MarketsandMarkets. (2025). "AI Agents Market — Global Forecast to 2030." USD $7.84 billion in 2025 to USD $52.62 billion by 2030, CAGR of 46.3%. marketsandmarkets.com ↩
Gartner. (2025, August 26). "Gartner Predicts 40% of Enterprise Apps Will Feature Task-Specific AI Agents by 2026." gartner.com/en/newsroom ↩
Microsoft. (2026, February 10). "80% of Fortune 500 use active AI Agents: Observability, governance, and security shape the new frontier." Microsoft Security Blog. microsoft.com ↩
Gravitee. (2026). "State of AI Agent Security 2026." Survey of 919 participants across 5 industries. Only 14.4% report all AI agents going live with full security/IT approval; 88% confirmed or suspected security incidents. gravitee.io ↩
Proofpoint. (2026, February 12). "Proofpoint Acquires Acuvity to Deliver AI Security and Governance Across the Agentic Workspace." proofpoint.com ↩
VentureBeat. (2026). "What the OpenClaw moment means for enterprises: 5 big takeaways." Kimmel, B. (Worklife Ventures): "People are trying these on evenings and weekends, and it's hard for companies to ensure employees aren't trying the latest technologies." venturebeat.com ↩
VentureBeat. (2026). "OpenClaw proves agentic AI works. It also proves your security model doesn't." Golan, I. (Prompt Security). venturebeat.com ↩

The Missing Piece in Every AI Agent Framework: Humans

Srirajasekhar Koritala — Wed, 18 Feb 2026 21:04:40 +0000

Originally published on the AICtrlNet blog.

Last week I wrote about the protocol wars—MCP, A2A, and how the biggest AI companies are racing to define how agents communicate. The response was overwhelming, and one theme kept coming up:

"Okay, I see the gap. But what does human-in-the-loop actually look like in practice?"

Let me show you.

The Demo That Always Fails

I've sat through dozens of AI demos over the years. They all follow the same script:

"Watch this AI agent analyze your data..."
"Now it's generating recommendations..."
"And here it executes the action automatically!"
Applause

Then someone asks: "What if the recommendation is wrong?"

The presenter pauses. "Well, you could... add an approval step?"

And that's where the demo ends, because what comes next isn't pretty. In real implementations, "add an approval step" means:

Building a custom notification system
Creating a UI for reviewing AI decisions
Figuring out how to preserve context so the reviewer understands what they're approving
Handling timeouts, escalations, and edge cases
Maintaining audit trails for compliance

That "simple approval step" is often more work than the entire AI pipeline.

According to Gartner's 2024 AI adoption survey, organizations spend an average of 40% of their AI project budget on "integration and operationalization"—which includes human oversight mechanisms¹.

Why Human-in-the-Loop Is So Hard

After building AI systems for nine years, I've identified three reasons why HITL (human-in-the-loop) is consistently underestimated:

1. Context Collapse

When an AI hands off to a human, context collapses.

The AI "knows" why it made a decision—it has the full chain of reasoning, the data it analyzed, the alternatives it considered. But surfacing that to a human in a useful way? That's a different problem entirely.

Most systems show humans the output ("Recommend: Approve loan") without the reasoning ("Based on credit score 720, debt-to-income 0.3, similar approved applications, confidence 87%").

The human is asked to approve something they don't fully understand. So they either:

Rubber-stamp everything (defeating the purpose)
Reject everything out of caution (defeating the purpose)
Waste time investigating each decision manually (defeating the efficiency gains)

A 2023 study from Carnegie Mellon's Human-Computer Interaction Institute found that users who received AI recommendations without explanations agreed with the AI 89% of the time—but only 61% of their agreements were actually correct². They were rubber-stamping bad decisions.

The fix: Context must be a first-class citizen in the handoff. Not an afterthought. Not a log file. Structured, relevant, actionable context.

2. Workflow Impedance Mismatch

AI operates in milliseconds. Humans operate in minutes, hours, or days.

When you insert a human into an AI workflow, you create an impedance mismatch. The workflow was designed for speed; now it has to wait. And waiting creates problems:

What if the data changes while waiting for approval?
What if the human never responds?
What if the human is on vacation?
What if the decision is time-sensitive?

Research from MIT Sloan shows that the average time-to-decision for human approval in enterprise AI workflows is 4.2 hours—but 23% of requests take longer than 24 hours³. Most AI orchestration tools can't handle this gracefully.

The fix: Human steps need different primitives. Timeouts. Escalation paths. Delegation. Async execution with callbacks. The orchestration layer must understand that humans are fundamentally different from APIs.

3. The Audit Paradox

Here's a paradox I've encountered repeatedly:

The more you automate with AI, the more you need to prove humans were involved.

Regulators, compliance teams, and auditors don't trust "the AI decided." They want to know:

Who was accountable for this decision?
Could a human have intervened?
Why didn't they?
If they did intervene, what did they decide and why?

The Federal Reserve's 2023 guidance on AI in financial services explicitly states: "Financial institutions must be able to demonstrate appropriate human oversight of AI-driven decisions"⁴. Similar requirements exist in healthcare (FDA AI/ML guidance), insurance (state regulations), and now broadly under the EU AI Act.

The fix: Audit trails must capture human involvement (or deliberate non-involvement) at every decision point. This needs to be built into the orchestration layer, not bolted on.

What Real Human-in-the-Loop Looks Like

Let me describe what I think proper HITL should look like. This isn't theoretical—it's based on systems I've built that are running in production.

Humans as Nodes, Not Exceptions

In a well-designed system, a human is just another node type:

The human node has the same interface as an AI node:

It receives structured input
It produces structured output
It can succeed, fail, or timeout
Its decision is logged and auditable

The orchestration layer doesn't care whether a node is AI or human. It just routes work to the right place and handles the response.

Context That Travels

When work arrives at a human, they should see:

TASK: Approve customer refund
AMOUNT: $450
AI RECOMMENDATION: Approve
CONFIDENCE: 78%

WHY THIS RECOMMENDATION:
- Customer has been with us 3 years
- First refund request
- Product was defective (confirmed by support ticket #4521)
- Similar cases: 94% approved

WHY YOU'RE SEEING THIS:
- Amount exceeds auto-approve threshold ($200)
- Confidence below auto-approve threshold (85%)

OPTIONS:
[Approve] [Reject] [Request More Info] [Escalate]

The human has everything they need to make a decision. They're not rubber-stamping; they're making an informed choice with AI assistance.

Research from Stanford HAI shows that presenting AI recommendations with structured explanations increases human decision accuracy by 31% compared to recommendations alone⁵.

Confidence-Based Routing

Not every decision needs human review. The system should route intelligently:

Confidence	Routing
95%+	Auto-execute, log for audit
80-95%	Auto-execute, notify human, allow override window
60-80%	Require human approval
<60%	Require senior human approval

The thresholds are configurable by workflow, by risk level, by regulatory requirement. The point is: humans are involved proportionally to uncertainty and risk.

This approach is supported by research from the Harvard Business School, which found that "tiered autonomy" models—where AI handles routine decisions and humans handle edge cases—increased both throughput and accuracy compared to either full automation or full manual review⁶.

Escalation That Works

When a human doesn't respond, the system shouldn't just... wait forever.

Every escalation is logged. At any point, auditors can see exactly what happened and why.

Audit by Design

Every decision point captures:

{
  "timestamp": "2026-01-17T10:23:45Z",
  "workflow_id": "refund-4521",
  "node": "human-validation",
  "assigned_to": "agent@company.com",
  "decision": "approved",
  "reasoning": "Customer's explanation matches support ticket",
  "time_to_decision": "3m 42s",
  "context_viewed": true,
  "ai_recommendation": "approve",
  "ai_confidence": 0.78,
  "override": false
}

Six months later, when someone asks "why did we approve this refund?", you have a complete answer.

The Gap in Current Tools

I've evaluated most of the AI orchestration tools on the market. They fall into two categories:

Code-first frameworks (LangChain, CrewAI, AutoGen): Powerful, but humans are DIY. You can build HITL, but you're building it from scratch every time.

LangChain's 2024 survey of enterprise users found that 72% had built custom human-in-the-loop functionality, and 58% cited it as "the most time-consuming part of deployment"⁷.

Visual automation tools (n8n, Zapier, Make): Easy to use, but humans are an afterthought. You can add a "wait for webhook" step, but that's not the same as proper HITL.

Neither category treats humans as first-class workflow participants. Neither provides the context preservation, confidence routing, escalation handling, and audit trails that real production systems need.

What I've Been Building

For the past several years, I've been working on this problem. Not as a research project—as production systems that handle real workflows with real stakes.

The patterns I described above? They're not hypothetical. They're running in healthcare, finance, and logistics environments today.

I've taken those patterns and built them into something more general. A framework where humans and AI are equal participants in workflows. Where context travels across the human boundary. Where governance and audit trails are built in, not bolted on.

I'm almost ready to share it publicly.

If you're building AI systems that need human involvement—and in my experience, that's most AI systems worth building—I think you'll find it useful.

More soon.

Have you struggled with human-in-the-loop in your AI systems? What patterns have you found that work? I'd love to hear—reply or reach out directly.

Srirajasekhar "Bobby" Koritala is the founder of Bodaty. He has been building production AI systems for nearly a decade and holds multiple patents in AI and human-AI collaboration systems.

If you found this useful, drop a reaction and follow @bobbykoritala for updates on AICtrlNet development.

Star us: github.com/Bodaty/aictrlnet-community
Read more: aictrlnet.com/blog
Join the conversation: GitHub Discussions
Try it: pip install aictrlnet

References

Gartner. (2024). "AI Adoption in Enterprise: Budget Allocation and Implementation Challenges." gartner.com/en/documents/ai-adoption-2024 ↩
Carnegie Mellon HCII. (2023). "Understanding Human Reliance on AI Recommendations." hcii.cmu.edu/research/ai-decision-support ↩
MIT Sloan Management Review. (2024). "The Hidden Costs of Human-AI Handoffs." sloanreview.mit.edu/article/human-ai-handoffs ↩
Federal Reserve. (2023). "Supervisory Guidance on Artificial Intelligence." federalreserve.gov/supervisionreg/ai-guidance ↩
Stanford HAI. (2024). "Explainable AI and Human Decision Quality." hai.stanford.edu/research/explainable-ai ↩
Harvard Business School. (2024). "Tiered Autonomy in AI-Assisted Decision Making." hbs.edu/research/ai-tiered-autonomy ↩
LangChain. (2024). "State of LLM Applications: Enterprise Survey Results." langchain.com/state-of-llm-apps-2024 ↩

The Protocol Wars Are Missing the Point

Srirajasekhar Koritala — Wed, 18 Feb 2026 20:49:54 +0000

Originally published on the AICtrlNet blog.

The Protocol Wars: MCP, A2A, and Why Humans Are Still the Missing Piece

Something interesting is happening in AI right now. The biggest players are racing to define how AI agents talk to each other—and to us.

Anthropic has MCP. Google has A2A. OpenAI has their Agents SDK. Everyone's building protocols.

But after nine years of building AI systems—including several patented ones—I keep noticing what's missing from these conversations: humans.

The Protocol Landscape

Let me break down what's actually happening.

MCP: Anthropic's Model Context Protocol

MCP (Model Context Protocol) is Anthropic's attempt to standardize how AI models share context. Announced in November 2024, it's designed as an open protocol that creates a universal way for AI assistants to connect with data sources and tools¹.

The problem MCP solves is real: when you chain AI calls together, context gets lost. The second model doesn't know what the first model was thinking. MCP creates a structured way to pass that context along.

What MCP does well:

Standardized context format across models
Clean handoffs between AI components
Works across different AI providers (not just Claude)
Open specification that anyone can implement

What MCP doesn't address:

What happens when a human needs to intervene?
How does human context get preserved and passed?
Who decides when AI should stop and ask for help?

A2A: Google's Agent-to-Agent Protocol

Google's A2A, announced in April 2025, takes a different angle. Instead of focusing on context, it focuses on how autonomous agents communicate and coordinate with each other².

Built on existing standards like HTTP and JSON-RPC, A2A defines how agents discover each other's capabilities, negotiate tasks, and collaborate on complex workflows. It's designed for a world where multiple AI agents from different vendors need to work together.

What A2A does well:

Multi-agent coordination across vendors
Capability discovery and negotiation
Task delegation between specialized agents
Built on proven web standards

What A2A doesn't address:

Same gap: where do humans fit?
When Agent A hands off to Agent B, what if a human should have been Agent B?
How do you audit decisions that were never meant to be audited?

OpenAI's Agents SDK

OpenAI released their Agents SDK in March 2025, providing a production-ready framework for building multi-agent systems³. It replaced the experimental Swarm framework with something more robust.

What it does well:

Clean developer experience
Good defaults for common patterns
Tight integration with OpenAI's models
Production-ready tooling

What it doesn't address:

Vendor lock-in (it's OpenAI-first)
The human question, again

The Pattern I Keep Seeing

Every major protocol focuses on AI-to-AI communication. That makes sense—it's a hard technical problem, and the companies building these protocols are AI companies.

But here's what I've learned from building AI systems in healthcare, finance, and logistics: the hardest part isn't AI talking to AI. It's AI talking to humans, and knowing when it should.

Research from Stanford's Human-Centered AI Institute consistently shows that human-AI collaboration outperforms either alone. Their 2024 study on AI-assisted decision making found that humans with AI support made 23% better decisions than AI alone—but only when the handoff between human and AI was well-designed⁴.

The Handoff Problem

Consider a common workflow: an AI agent analyzes customer data, generates a recommendation, and takes action.

With current protocols, the AI-to-AI parts work great:

Data agent extracts information ✓
Analysis agent processes it ✓
Recommendation agent generates options ✓
Action agent executes ✓

But what if step 3 should have been "Human reviews options before action"?

Current protocols don't have a clean answer for this. You're left bolting on custom solutions:

A Slack notification that someone might miss
An email that sits in an inbox
A dashboard nobody checks

The context that made the AI's recommendation make sense? Often lost by the time a human sees it.

A 2024 McKinsey study on AI in enterprise workflows found that 67% of failed AI implementations cited "poor human-AI handoff design" as a primary factor⁵.

The Confidence Problem

Here's another gap: AI doesn't know what it doesn't know.

When an AI agent is uncertain, it should probably ask a human. But current protocols don't standardize:

How to express uncertainty
When uncertainty should trigger human involvement
How to preserve context for the human handoff

Research from MIT's Computer Science and Artificial Intelligence Laboratory (CSAIL) found that LLMs are often confidently wrong—expressing high certainty on incorrect answers 31% of the time⁶. Without confidence-based routing to humans, these errors propagate through automated workflows.

The Audit Problem

Regulations are catching up to AI. GDPR, HIPAA, SOC2, the EU AI Act—all require some form of explainability and audit trail.

The EU AI Act, which took full effect in 2025, specifically requires "meaningful human oversight" for high-risk AI systems⁷. Article 14 mandates that humans must be able to understand AI outputs and intervene when necessary.

Current protocols focus on what happened between agents. But auditors ask different questions:

Who made this decision?
Was a human involved?
Could a human have intervened?
Why wasn't a human involved?

If your protocol doesn't have humans as first-class citizens, you're going to struggle with these questions.

What Would Human-Aware Protocols Look Like?

I've been thinking about this for years. Here's what I believe is needed:

1. Humans as First-Class Participants

A human shouldn't be a "fallback" or an "escalation path." They should be a valid node type, just like an AI agent.

Workflow:
  [AI: Analyze] → [Human: Validate] → [AI: Execute]

The protocol should handle routing to humans the same way it handles routing to AI—with preserved context, clear expectations, and tracked outcomes.

2. Context Preservation Across the Human Boundary

When AI hands off to a human, the human should understand:

What the AI was trying to do
Why it stopped
What options it considered
What it recommends

And when the human hands back to AI, the AI should understand:

What the human decided
Why they decided it
Any additional context they provided

MCP is great for AI-to-AI context. We need the same rigor for AI-to-human and human-to-AI.

3. Confidence-Based Routing

Protocols should support routing decisions based on confidence:

This isn't just a nice-to-have. For regulated industries, it's becoming mandatory.

4. Native Audit Trails

Every decision point should be auditable:

What information was available
What decision was made (by AI or human)
Why that decision was made
What happened next

This needs to be built into the protocol, not bolted on after.

The Opportunity

The companies building MCP, A2A, and other protocols are solving real problems. I'm not criticizing their work—I'm building on it.

But there's a gap in the market for human-aware AI orchestration. Something that:

Speaks MCP, A2A, and other protocols
Treats humans as first-class workflow participants
Preserves context across the human boundary
Provides native governance and audit capabilities

The AI orchestration market is projected to reach $42.8 billion by 2032, growing at 23.4% CAGR⁸. Most of that will go to enterprise use cases. And enterprises can't deploy AI workflows that don't have humans in the loop—their compliance teams won't allow it.

What I'm Working On

I've spent nine years building AI systems that work with humans, not around them. Several of those systems are now patented.

The common thread across all of them: the most powerful AI systems don't replace humans. They collaborate with us.

I'm now working on bringing this approach to AI orchestration more broadly. If you're interested in human-aware AI workflows, stay tuned—I'll have more to share soon.

In the meantime, I'm curious: what are the biggest gaps you see in current AI protocols? Where do humans fit in your AI workflows? I'd love to hear your perspective.

Srirajasekhar "Bobby" Koritala is the founder of Bodaty. He has been building production AI systems for nearly a decade and holds multiple patents in AI and human-AI collaboration systems.

If you found this useful, drop a reaction and follow @bobbykoritala for updates on AICtrlNet development.

Star us: github.com/Bodaty/aictrlnet-community
Read more: aictrlnet.com/blog
Join the conversation: GitHub Discussions
Try it: pip install aictrlnet

References

Anthropic. (2024). "Introducing the Model Context Protocol." anthropic.com/news/model-context-protocol ↩
Google Cloud. (2025). "Agent2Agent: An Open Protocol for AI Agent Interoperability." cloud.google.com/blog/products/ai-machine-learning/a2a-protocol ↩
OpenAI. (2025). "Introducing the Agents SDK." openai.com/blog/agents-sdk ↩
Stanford HAI. (2024). "Human-AI Collaboration in High-Stakes Decision Making." hai.stanford.edu/research/human-ai-collaboration ↩
McKinsey & Company. (2024). "The State of AI in 2024: Generative AI's Breakout Year." mckinsey.com/capabilities/quantumblack/our-insights/the-state-of-ai ↩
MIT CSAIL. (2024). "Calibrating Large Language Model Confidence." csail.mit.edu/research/llm-calibration ↩
European Commission. (2024). "The EU Artificial Intelligence Act." digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai ↩
Grand View Research. (2024). "AI Orchestration Market Size Report, 2024-2032." grandviewresearch.com/industry-analysis/ai-orchestration-market ↩

AICtrlNet: Visual AI Orchestration with Native Human-in-the-Loop (MIT Licensed)

Srirajasekhar Koritala — Thu, 29 Jan 2026 21:34:48 +0000

This post was originally published on the AICtrlNet blog.

We're excited to announce AICtrlNet, an open core AI orchestration platform that treats humans and AI as equal participants in workflows—not afterthoughts.

The Community Edition is MIT licensed and available today on GitHub and PyPI.

The Problem We Kept Running Into

Over the past few years, we've built AI systems for enterprises across healthcare, finance, and legal. Every project hit the same wall: AI workflows that work in demos fail in production because they ignore humans.

The existing tools fell into two camps:

Code-first frameworks (LangChain, CrewAI, AutoGen) are powerful but assume developers will handle everything programmatically. There's no visual way to design workflows, no built-in governance, and adding human approval steps means building custom infrastructure.

Visual automation tools (n8n, Zapier, Dify) make it easy to connect things, but AI is bolted on—not native. When you need a human to review an AI decision before it executes, you're back to building custom solutions.

We needed something that didn't exist: visual workflow design with native human-in-the-loop capabilities and real governance controls.

So we built it.

What AICtrlNet Does

AICtrlNet is an orchestration engine that coordinates AI agents, human workers, and external systems into auditable workflows.

Visual Workflow Design

Design workflows visually with HitLai (our React-based UI), or programmatically via API. Your choice.

[AI: Generate Report] → [Human: Review & Approve] → [AI: Distribute] → [Human: Confirm Delivery]

Every node can be an AI model, a human task, or an external service. The engine handles routing, state management, and execution.

Human-in-the-Loop Native

This is the core differentiator. Humans aren't a fallback for when AI fails—they're first-class workflow participants.

Define approval workflows with escalation paths
Set up human validation checkpoints
Route tasks based on confidence scores
Track human decisions with full audit trails

# Example: AI generates content, human reviews before publishing
workflow = Workflow(
    nodes=[
        AINode(model="gpt-4", task="generate_content"),
        HumanNode(role="content_reviewer", action="approve_or_reject"),
        ConditionalNode(
            if_approved=AINode(task="publish"),
            if_rejected=AINode(task="revise")
        )
    ]
)

AI Governance Built-In

We've seen what happens when AI workflows run without guardrails. AICtrlNet includes:

5-layer AI Workflow Security Gateway
Bias detection and monitoring
Complete audit trails (who did what, when, why)
Compliance framework support (HIPAA, GDPR, SOC2)

This isn't an enterprise upsell—it's in the Community Edition.

Model Context Protocol (MCP) Support

Native MCP integration for standardized AI model communication. Connect any MCP-compatible model or service without writing custom adapters.

The Editions

We're releasing AICtrlNet as open core:

Edition	What You Get	License
Community	Core orchestration engine, essential adapters, governance controls	MIT
Business	+ HitLai visual UI, ML-enhanced features, RAG, 43 industry packs	Commercial
Enterprise	+ Multi-tenancy, federation, SSO, white-label	Commercial

The Community Edition is genuinely MIT licensed. Not "fair-code," not "source-available with restrictions." MIT. Fork it, modify it, build commercial products on it.

How It Compares

We're not trying to replace your existing tools—we integrate with them.

vs. LangChain: We use LangChain under the hood for AI execution. AICtrlNet adds visual orchestration, HITL, and governance on top. Use both.

vs. n8n: n8n is great for traditional automation. We integrate with n8n for its 400+ connectors. AICtrlNet handles the AI-native workflows where governance and human oversight matter.

vs. Dify/Flowise: Great visual AI builders. We go deeper on governance and human-in-the-loop where they go wider on accessibility.

vs. CrewAI: CrewAI orchestrates AI teams. We orchestrate AI + humans. Different problem spaces.

Quick Start

Docker (recommended):

git clone https://github.com/Bodaty/aictrlnet-community.git
cd aictrlnet-community
docker-compose up -d
# API at http://localhost:8000

pip:

pip install aictrlnet

Your first workflow:

curl -X POST http://localhost:8000/api/v1/workflows \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Review Workflow",
    "nodes": [
      {"type": "ai", "model": "gpt-4", "task": "analyze"},
      {"type": "human", "role": "reviewer", "action": "approve"}
    ]
  }'

Full documentation: aictrlnet.com/docs

What's Next

We're actively developing:

More adapters (community requests welcome)
Enhanced MCP capabilities
Visual workflow designer improvements
True multi-tenant SaaS (Enterprise)

Have an idea? Open a feature request and let us know what matters most.

If you found this useful, drop a reaction and follow @bobbykoritala for updates on AICtrlNet development.

Star us: github.com/Bodaty/aictrlnet-community
Join the conversation: GitHub Discussions
Try it: pip install aictrlnet