Ved is an HGateway (HITL gateway) agent: it owns and resolves every HITL your agents raise. Register the interrupt, hand it to Ved, and your agent goes back to doing the one thing it's actually coded for: its business logic, not babysitting a raised HITL through to resolution.
The sandbox is a live, pre-seeded Ved workspace, not a video, not a mockup. Pick a scenario, watch the agent raise its HITL in Slack, and work the resolution yourself: ask questions, request the impact analysis, forward it to a colleague. No account, no install, nothing to configure.
Open the live sandbox↗None of this shows up in a demo. It shows up the first time a real one goes wrong.
The responder isn't given anything to work with, just a prompt and two buttons. They guess, or pick whatever feels most right, never sure it's actually right.
Nobody's watching what happens if the responder doesn't answer. The HITL just waits, indefinitely, if it has to.
Wrong person got the ask? Re-routing to someone else means a code change and a deployment, not a click.
Even when a human explains why they decided something, there's nowhere for that reasoning to live. It's gone once the thread goes quiet.
Every HITL is treated like the first time it's ever happened. Nothing gets quieter or smarter over time; it's just noise, every time.
You can't apply a rule to a specific HITL type, or to a whole team of agents. There's no lever to pull, only code to ship.
That's not a gap left to close as agents get smarter. It's a constraint to design for. Ved doesn't remove that gate: it owns how it's executed, so the question stops being "how do we remove the human" and becomes "who's actually running this checkpoint."
Today's gate is a raw interrupt() and a one-off, hand-written message, coded once inside a single agent. It works, until it needs an on-the-fly change, has to survive a stale response, or needs to be more than a dead-end prompt with no way to interact back.
HGateway is infrastructure for agent ↔ human interaction, and Ved is the agent that runs it.
This is the shift being sold: the entire HITL lifecycle, handed to an agent built to own it, which is what makes everything that follows possible in the first place.
One decorator. One typed call. The gate moves out of your repo and into Ved.
Once Ved owns the full lifecycle (not just the moment of raising it), every stage becomes something that can be worked on, without you touching a line of agent code.
A HITL that's just been delivered doesn't go stale sitting with no interaction on it: Ved moves it forward proactively, so business operations never stall on a thread nobody's watching.
The responder can ask for impact analysis, request a recommendation, forward it to a peer, or interrogate the HITL directly, every exchange feeding a reasoning stack that makes the next HITL sharper than the last.
One place to see why every human intervened, across every agent, every team, not because each one logged it, but because Ved was the one running it.
None of this ships because it's a listed feature. It ships because Ved now owns a lifecycle that can hold it, and that's exactly why the list keeps growing.
Current release supports one ADK and one comm channel end to end; every other row below is on the roadmap.
Running one of the "coming soon" rows already? Tell us, and we'll prioritize it.
Two lines of your own logic. Everything after the interrupt belongs to Ved now.
@hg.hitl_node binds the current LangGraph state and config so the SDK can build context automatically.
hg.raise_approval() (one of ten typed wrapper calls) hands the HITL to Ved and suspends the graph; the typed response comes back on resume.
Delivery, interaction, and resolution (over Slack today, more channels next), none of that is your agent's problem anymore.
from typing import TypedDict from langgraph.graph import StateGraph from langgraph.types import interrupt import hgateway_sdk as hg hg.init(channels=["#finance"], ttl_seconds=3600) class RefundState(TypedDict): amount: float decision: str @hg.hitl_nodedef review_node(state: RefundState): reply = interrupt({"question": f"Approve refund of ${state['amount']}?"}) return {"decision": reply["decision"]} resp = hg.raise_approval( "approve-refund", f"Approve refund of ${state['amount']}?", ) return {"decision": resp["decision"]} graph = StateGraph(RefundState) graph.add_node("review", review_node)
Ved works with any workspace today over LangGraph and Slack. Tell us your ADK and channel and we'll use it to prioritize what ships next.
Generated straight from the SDK's own docstrings: @hg.hitl_node, hg.raise_interrupt, and every content/response schema.
Open alpha is live: create a workspace and connect your agent in minutes, no invite required.