DEV Community: Chandan Galani

AGENTS CONTROL PLANE

Chandan Galani — Thu, 08 Jan 2026 12:08:32 +0000

We built a deterministic control layer that sits between AI agents
and production systems. In healthcare, this means:

Pre-execution validation (HIPAA, FDA compliance)
Immutable audit trail (survives admin wipes)
Shadow mode testing (zero patient impact)

We just ran 284K transactions through shadow mode and caught $25K+
in risky actions that would've violated policies.

Would you be open to a 15min call? Happy to show how this maps to
clinical compliance workflows.

Live demo API: http://galani-alb-2013282884.ap-south-1.elb.amazonaws.com
GitHub: https://github.com/LOLA0786/PrivateVault-Mega-Repo

Intent should have rules — not just algorithms. We’re building an Intent Social Discovery platform that understands intent before action. Coming 2/26.

Chandan Galani — Fri, 02 Jan 2026 03:51:28 +0000

Intent should have rules — not just algorithms. We’re building an Intent Social Discovery platform that understands intent before action. Coming 2/26.

Chandan Galani — Wed, 31 Dec 2025 07:54:34 +0000

Thoughts become intent. Intent should have rules — not just algorithms. We’re building an Intent Social Discovery platform that understands intent before action. Coming 2/26.

Chandan Galani — Wed, 31 Dec 2025 07:54:21 +0000

How should AI actions be authorized before execution? Built a small GPT to explore this

Chandan Galani — Sun, 28 Dec 2025 07:55:12 +0000

We’ve been thinking a lot about how agentic AI systems should be controlled before they touch real systems (money, data, prod infra).

We put together a small public GPT that simulates pre-execution authorization:

You describe a proposed action

It returns ALLOW or BLOCK, with reasons

No execution, no enforcement — just evaluation

It’s meant as a discussion artifact, not a product pitch.

Link:
https://chatgpt.com/g/g-6950ce624e988191a12212c322711656-uaal-pre-execution-authorization-simulator

Genuinely curious:

How are others thinking about authorization vs execution for AI agents?

Should this live inside the agent, or outside as a control plane?

Happy to take criticism — this is early thinking.

Establishing the zero-trust standard for AI agents. We want to move the industry from just "monitoring" AI to actually "controlling" it—where every autonomous action is replay-verifiable, CI-enforced, and cryptographically proven.

Chandan Galani — Thu, 25 Dec 2025 09:30:41 +0000

I’m building a deterministic policy firewall for AI systems — looking for technical feedback

Chandan Galani — Thu, 25 Dec 2025 05:58:27 +0000

I’ve been working on a small but opinionated system and would love technical feedback from people who’ve dealt with AI in regulated or high-risk environments.

The core idea is simple:

AI systems can propose actions.

Something else must decide whether those actions are allowed to execute.

This project is not about “understanding intent” perfectly.

Intent normalization is deliberately lossy (regex / LLM / upstream systems).

The invariant is a deterministic policy layer that:

blocks unsafe or illegal execution
fails closed when inputs are ambiguous
produces a tamper-evident audit trail

Think of it as an execution firewall or control plane for AI agents.

I’ve tested it across:

fintech (loan approvals, AML-style constraints)
healthtech (prescription safety, controlled substances, pregnancy)
legal (M&A, antitrust thresholds)
insurance, e-commerce, and government scenarios
including unstructured natural-language inputs

This is early-stage and intentionally conservative.

False positives escalate; false negatives are unacceptable.

Repo: https://github.com/LOLA0786/Intent-Engine-Api

I’m not looking for product feedback — mainly architectural criticism:

Where does this break down?
What would you challenge if you were deploying this?
What’s missing at the execution boundary?

Happy to clarify assumptions.

We built an API that lets AI systems check if humans actually care before acting. It’s a simple intent-verification gate for AI agents. Early access, prepaid usage.

Chandan Galani — Tue, 23 Dec 2025 06:18:44 +0000

This link will take you to a page that’s not on LinkedIn

lnkd.in

Why AI Agents Should Check for Human Intent Before Acting

Chandan Galani — Tue, 23 Dec 2025 05:48:18 +0000

AI agents are getting very good at doing things.

They can send messages, trigger workflows, approve steps, and automate decisions. But while building and observing agentic systems, I kept running into a quiet problem:

AI agents often act without knowing whether humans actually care.

The missing signal

Most agent workflows answer questions like:

What is the next best action?

Is this action allowed by policy?

Is the model confident enough?

But they rarely answer:

Is there real human intent or demand behind this action right now?

As a result, agents can:

trigger unnecessary automations

send low-signal notifications

act prematurely

create “AI noise” instead of value

This isn’t a model problem — it’s a decision gating problem.

Intent vs. instruction

Human intent is different from:

prompts

rules

feedback loops

Intent answers whether something should happen at all, not how it should happen.

In many systems, intent is implicit or assumed:

inferred from logs

guessed from past behavior

approximated via confidence scores

But intent can also be treated as a first-class signal.

A simple idea: intent-aware gating

Instead of letting agents always act, we can introduce a lightweight gate:

Human intent is captured or injected into the system

Before acting, the agent checks for intent

If intent exists → action proceeds

If not → action is delayed, skipped, or downgraded

This isn’t “human approval” or heavy human-in-the-loop workflows.
It’s closer to a relevance check.

Where this helps

This pattern seems especially useful for:

agentic automation

decision escalation systems

notification-heavy workflows

governance or compliance-sensitive actions

Anywhere an agent can technically act, but maybe shouldn’t unless humans actually care.

Open questions

I’m still exploring a lot here, and I’m curious how others think about this:

How do you currently infer or validate human intent in your systems?

Is intent something that should be explicit or inferred?

Where does intent gating break down or become unnecessary?

I’ve been experimenting with this idea as a small API to test the concept in practice, but the core question is architectural, not product-specific.

If you’re building agentic systems or thinking about AI decision boundaries, I’d love to hear how you approach this problem.