Month: January 2026

Cloudflare has open sourced tokio-quiche, an asynchronous QUIC and HTTP/3 Rust library that wraps its battle tested quiche implementation with the Tokio runtime. The library has been refined inside production systems such as Apple iCloud Private Relay, next generation Oxy based proxies and WARP’s MASQUE client, where it handles millions of HTTP/3 requests per second with low latency and high throughput. tokio-quiche targets Rust teams that want QUIC and HTTP/3 without writing their own UDP and event loop integration code.

From quiche to tokio-quiche

quiche is Cloudflare’s open source QUIC and HTTP/3 implementation written in Rust and designed as a low level, sans-io library. It implements the QUIC transport state machine, including connection establishment, flow control and stream multiplexing, while making no assumptions about how applications perform IO. To use quiche directly, integrators must open UDP sockets, send and receive datagrams, manage timers and feed all packet data into quiche in the correct order. This design gives flexibility, but it makes integration error prone and time consuming.

tokio-quiche packages this integration work into a reusable crate. It combines the sans-io QUIC or HTTP/3 implementation from quiche with the Tokio async runtime, and exposes an API that already manages UDP sockets, packet routing and calls into the quiche state machine.

Actor based architecture on Tokio

Internally, tokio-quiche uses an actor model on top of Tokio. Actors are small tasks with local state that communicate through message passing over channels, which aligns well with sans-io protocol implementations that own internal state and operate on message like buffers.

The primary actor is the IO loop actor, which moves packets between quiche and the UDP socket. One of the key message types is an Incoming struct that describes received UDP packets. Async integration follows a fixed pattern, the IO loop awaits new messages, translates them into inputs for quiche, advances the QUIC state machine, then translates outputs into outbound packets that are written back to the socket.

For each UDP socket, tokio-quiche spawns two important tasks. InboundPacketRouter owns the receiving half of the socket and routes inbound datagrams by destination connection ID to per connection channels. IoWorker is the per connection IO loop and drives a single quiche Connection, interleaving calls to quiche with calls to application specific logic implemented through ApplicationOverQuic. This design encapsulates connection state inside each actor and keeps QUIC processing isolated from higher level protocol code.

ApplicationOverQuic and H3Driver

QUIC is a transport protocol and can carry multiple application protocols. HTTP/3, DNS over QUIC and Media over QUIC are examples covered by IETF specifications. To avoid coupling tokio-quiche to a single protocol, Cloudflare team exposes an ApplicationOverQuic trait. The trait abstracts over quiche methods and the underlying IO, and presents higher level events and hooks to the application that implements the protocol. For example, the HTTP/3 debug and test client h3i uses a non HTTP/3 implementation of ApplicationOverQuic.

On top of this trait, tokio-quiche ships a dedicated HTTP/3 focused implementation named H3Driver. H3Driver connects quiche’s HTTP/3 module to the IO loop actor and converts raw HTTP/3 events into higher level events with asynchronous body streams that are convenient for application code. H3Driver is generic and exposes ServerH3Driver and ClientH3Driver variants that add server side and client side behavior on top of the core driver. These components provide the building blocks for HTTP/3 servers and clients that share implementation patterns with Cloudflare’s internal infrastructure.

Production usage and roadmap

tokio-quiche has been used for several years inside Cloudflare before its public release. It powers Proxy B in Apple iCloud Private Relay, Oxy based HTTP/3 servers and the WARP MASQUE client, as well as the async version of h3i. In the WARP client, MASQUE based tunnels built on tokio-quiche replace earlier WireGuard based tunnels with QUIC based tunnels. These systems run at Cloudflare edge scale and demonstrate that the integration can sustain millions of HTTP/3 requests per second in production.

Cloudflare positions tokio-quiche as a foundation rather than a complete HTTP/3 framework. The library exposes low level protocol capabilities and example client and server event loops, and leaves room for higher level projects to implement opinionated HTTP servers, DNS over QUIC clients, MASQUE based VPNs and other QUIC applications on top. By releasing the crate, Cloudflare aims to lower the barrier for Rust teams to adopt QUIC, HTTP/3 and MASQUE, and to align external integrations with the same transport stack used in its edge services.

Key Takeaways

tokio-quiche = quiche + Tokio: tokio-quiche is an async Rust library that integrates Cloudflare’s sans-io QUIC and HTTP/3 implementation, quiche, with the Tokio runtime, so developers do not need to hand write UDP and event loop plumbing.

Actor based architecture for QUIC connections: The library uses an actor model on Tokio, with an InboundPacketRouter that routes UDP datagrams by connection ID and an IoWorker that drives a single quiche Connection per task, keeping transport state isolated and composable.

ApplicationOverQuic abstraction: Protocol logic is separated through the ApplicationOverQuic trait, which abstracts over quiche and I O details so different QUIC based protocols such as HTTP/3, DNS over QUIC or custom protocols can be implemented on top of the same transport core.

HTTP/3 via H3Driver, ServerH3Driver and ClientH3Driver: tokio-quiche ships H3Driver plus ServerH3Driver and ClientH3Driver variants that bridge quiche’s HTTP/3 module to async Rust code, exposing HTTP/3 streams and bodies in a way that fits typical Tokio based services.

Check out the Technical details. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well.
The post How Cloudflare’s tokio-quiche Makes QUIC and HTTP/3 a First Class Citizen in Rust Backends appeared first on MarkTechPost.

In this tutorial, we implement an agentic AI pattern using LangGraph that treats reasoning and action as a transactional workflow rather than a single-shot decision. We model a two-phase commit system in which an agent stages reversible changes, validates strict invariants, pauses for human approval via graph interrupts, and commits or rolls back only then. With this, we demonstrate how agentic systems can be designed with safety, auditability, and controllability at their core, moving beyond reactive chat agents toward structured, governance-aware AI workflows that run reliably in Google Colab using OpenAI models. Check out the Full Codes here.

Copy CodeCopiedUse a different Browser!pip -q install -U langgraph langchain-openai

import os, json, uuid, copy, math, re, operator
from typing import Any, Dict, List, Optional
from typing_extensions import TypedDict, Annotated

from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage, HumanMessage, AIMessage, AnyMessage
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.types import interrupt, Command

def _set_env_openai():
if os.environ.get(“OPENAI_API_KEY”):
return
try:
from google.colab import userdata
k = userdata.get(“OPENAI_API_KEY”)
if k:
os.environ[“OPENAI_API_KEY”] = k
return
except Exception:
pass
import getpass
os.environ[“OPENAI_API_KEY”] = getpass.getpass(“Enter OPENAI_API_KEY: “)

_set_env_openai()

MODEL = os.environ.get(“OPENAI_MODEL”, “gpt-4o-mini”)
llm = ChatOpenAI(model=MODEL, temperature=0)

We set up the execution environment by installing LangGraph and initializing the OpenAI model. We securely load the API key and configure a deterministic LLM, ensuring that all downstream agent behavior remains reproducible and controlled. Check out the Full Codes here.

Copy CodeCopiedUse a different BrowserSAMPLE_LEDGER = [
{“txn_id”: “T001”, “name”: “Asha”, “email”: “ASHA@Example.com”, “amount”: “1,250.50”, “date”: “12/01/2025”, “note”: “Membership renewal”},
{“txn_id”: “T002”, “name”: “Ravi”, “email”: “ravi@example.com”, “amount”: “-500”, “date”: “2025-12-02”, “note”: “Chargeback?”},
{“txn_id”: “T003”, “name”: “Sara”, “email”: “sara@example.com”, “amount”: “700”, “date”: “02-12-2025”, “note”: “Late fee waived”},
{“txn_id”: “T003”, “name”: “Sara”, “email”: “sara@example.com”, “amount”: “700”, “date”: “02-12-2025”, “note”: “Duplicate row”},
{“txn_id”: “T004”, “name”: “Lee”, “email”: “lee@example.com”, “amount”: “NaN”, “date”: “2025/12/03”, “note”: “Bad amount”},
]

ALLOWED_OPS = {“replace”, “remove”, “add”}

def _parse_amount(x):
if isinstance(x, (int, float)):
return float(x)
if isinstance(x, str):
try:
return float(x.replace(“,”, “”))
except:
return None
return None

def _iso_date(d):
if not isinstance(d, str):
return None
d = d.replace(“/”, “-“)
p = d.split(“-“)
if len(p) == 3 and len(p[0]) == 4:
return d
if len(p) == 3 and len(p[2]) == 4:
return f”{p[2]}-{p[1]}-{p[0]}”
return None

def profile_ledger(rows):
seen, anomalies = {}, []
for i, r in enumerate(rows):
if _parse_amount(r.get(“amount”)) is None:
anomalies.append(i)
if r.get(“txn_id”) in seen:
anomalies.append(i)
seen[r.get(“txn_id”)] = i
return {“rows”: len(rows), “anomalies”: anomalies}

def apply_patch(rows, patch):
out = copy.deepcopy(rows)
for op in sorted([p for p in patch if p[“op”] == “remove”], key=lambda x: x[“idx”], reverse=True):
out.pop(op[“idx”])
for op in patch:
if op[“op”] in {“add”, “replace”}:
out[op[“idx”]][op[“field”]] = op[“value”]
return out

def validate(rows):
issues = []
for i, r in enumerate(rows):
if _parse_amount(r.get(“amount”)) is None:
issues.append(i)
if _iso_date(r.get(“date”)) is None:
issues.append(i)
return {“ok”: len(issues) == 0, “issues”: issues}

We define the core ledger abstraction along with the patching, normalization, and validation logic. We treat data transformations as reversible operations, allowing the agent to reason about changes safely before committing them. Check out the Full Codes here.

Copy CodeCopiedUse a different Browserclass TxnState(TypedDict):
messages: Annotated[List[AnyMessage], add_messages]
raw_rows: List[Dict[str, Any]]
sandbox_rows: List[Dict[str, Any]]
patch: List[Dict[str, Any]]
validation: Dict[str, Any]
approved: Optional[bool]

def node_profile(state):
p = profile_ledger(state[“raw_rows”])
return {“messages”: [AIMessage(content=json.dumps(p))]}

def node_patch(state):
sys = SystemMessage(content=”Return a JSON patch list fixing amounts, dates, emails, duplicates”)
usr = HumanMessage(content=json.dumps(state[“raw_rows”]))
r = llm.invoke([sys, usr])
patch = json.loads(re.search(r”[.*]”, r.content, re.S).group())
return {“patch”: patch, “messages”: [AIMessage(content=json.dumps(patch))]}

def node_apply(state):
return {“sandbox_rows”: apply_patch(state[“raw_rows”], state[“patch”])}

def node_validate(state):
v = validate(state[“sandbox_rows”])
return {“validation”: v, “messages”: [AIMessage(content=json.dumps(v))]}

def node_approve(state):
decision = interrupt({“validation”: state[“validation”]})
return {“approved”: decision == “approve”}

def node_commit(state):
return {“messages”: [AIMessage(content=”COMMITTED”)]}

def node_rollback(state):
return {“messages”: [AIMessage(content=”ROLLED BACK”)]}

We model the agent’s internal state and define each node in the LangGraph workflow. We express agent behavior as discrete, inspectable steps that transform state while preserving message history. Check out the Full Codes here.

Copy CodeCopiedUse a different Browserbuilder = StateGraph(TxnState)

builder.add_node(“profile”, node_profile)
builder.add_node(“patch”, node_patch)
builder.add_node(“apply”, node_apply)
builder.add_node(“validate”, node_validate)
builder.add_node(“approve”, node_approve)
builder.add_node(“commit”, node_commit)
builder.add_node(“rollback”, node_rollback)

builder.add_edge(START, “profile”)
builder.add_edge(“profile”, “patch”)
builder.add_edge(“patch”, “apply”)
builder.add_edge(“apply”, “validate”)

builder.add_conditional_edges(
“validate”,
lambda s: “approve” if s[“validation”][“ok”] else “rollback”,
{“approve”: “approve”, “rollback”: “rollback”}
)

builder.add_conditional_edges(
“approve”,
lambda s: “commit” if s[“approved”] else “rollback”,
{“commit”: “commit”, “rollback”: “rollback”}
)

builder.add_edge(“commit”, END)
builder.add_edge(“rollback”, END)

app = builder.compile(checkpointer=InMemorySaver())

We construct the LangGraph state machine and explicitly encode the control flow between profiling, patching, validation, approval, and finalization. We use conditional edges to enforce governance rules rather than rely on implicit model decisions. Check out the Full Codes here.

Copy CodeCopiedUse a different Browserdef run():
state = {
“messages”: [],
“raw_rows”: SAMPLE_LEDGER,
“sandbox_rows”: [],
“patch”: [],
“validation”: {},
“approved”: None,
}

cfg = {“configurable”: {“thread_id”: “txn-demo”}}
out = app.invoke(state, config=cfg)

if “__interrupt__” in out:
print(json.dumps(out[“__interrupt__”], indent=2))
decision = input(“approve / reject: “).strip()
out = app.invoke(Command(resume=decision), config=cfg)

print(out[“messages”][-1].content)

run()

We run the transactional agent and handle human-in-the-loop approval through graph interrupts. We resume execution deterministically, demonstrating how agentic workflows can pause, accept external input, and safely conclude with either a commit or rollback.

In conclusion, we showed how LangGraph enables us to build agents that reason over states, enforce validation gates, and collaborate with humans at precisely defined control points. We treated the agent not as an oracle, but as a transaction coordinator that can stage, inspect, and reverse its own actions while maintaining a full audit trail. This approach highlights how agentic AI can be applied to real-world systems that require trust, compliance, and recoverability, and it provides a practical foundation for building production-grade autonomous workflows that remain safe, transparent, and human-supervised.

Check out the Full Codes here. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well.
The post How to Design Transactional Agentic AI Systems with LangGraph Using Two-Phase Commit, Human Interrupts, and Safe Rollbacks appeared first on MarkTechPost.