HTTP got a new method in June 2026. The first one since PATCH landed in 2010. QUERY: a GET with a body, safe and idempotent by definition of the protocol, already usable server-side according to the first implementations.
Does it actually fix the problem my agents run into every day, or is it 1 more thing that sounds great in a spec and dies the moment it hits a corporate firewall?
Because the problem's been sitting there for a decade. Every agent I run, every script that hits a search endpoint or a filter API, does the same thing. Sends a POST with a JSON body, even though it's a read. No side effects, but the protocol doesn't know that. There's no safe retry and no cache to lean on. QUERY promises to fix that at the protocol level, not at the level of a naming convention some team agreed on in a Slack thread. Whether that promise holds outside the announcements is the actual question.
What RFC 10008 Actually Promises
RFC 10008 shipped as a Proposed Standard on June 15, 2026. Authors from greenbytes, Cloudflare, and Akamai, which tells you this wasn't a weekend side project. The method it defines does one specific thing: it lets a client send a request body the way POST does, while keeping the semantics of GET. Safe (no side effects on the server), idempotent (send it 5 times, get the same result), and by the letter of the spec, cacheable.
That last word carries weight most explainers skip past. Safe and idempotent aren't marketing language here. They're protocol-level guarantees, the same category of promise GET has always made and POST never did. A proxy, a CDN, a retry layer built by someone who never read your code can rely on QUERY behaving a certain way, because the spec says so, not because your team's internal wiki says so.
Which is exactly the gap agents have been falling into.
The POST-as-GET Hack Agents Live With
Every agent that searches, filters, or queries anything with more than a couple of parameters runs into the same wall. GET puts everything in the URL, and URLs have length limits, encoding headaches, and nowhere clean to put a nested filter object. So the fix everyone reached for, agents included, was: send a POST, put the search criteria in the body, call it a day.
It works. Right up until it doesn't. A POST carries no promise about being safe or repeatable. If an agent's HTTP call times out mid-request, there's no clean way to know if the server actually processed it. Retry blindly and you might duplicate a write that was never a write to begin with, because the endpoint doesn't behave like a search, it behaves like whatever POST implies to the layer that's reading it. Caches skip it entirely too. A shared cache in front of your API sees a POST and, correctly by spec, refuses to touch it. Doesn't matter that the body is just a filter for a product catalog. POST means "assume this changes something," and the infrastructure takes that literally.
I've had this exact failure mode more times than I want to admit: an agent making a search call, the call dropping mid-flight, and me staring at logs trying to figure out if the retry logic actually re-sent a read or accidentally hammered an endpoint twice because nothing in the protocol told it retrying was safe. It's the kind of bug that eats an afternoon and teaches you nothing except that the tool you're using was never built to answer the question you're asking it. Developers have been asking for a documented "GET with a body" since at least 2015, when the idea first got floated and shelved for lack of a strong enough argument against just using POST. Turns out the argument took 11 years to land.
If your agent's retry logic depends on hope, that's not retry logic.
Retries an Agent Could Actually Trust
This is the part that matters for anything running unattended: if an agent sends a QUERY request, it could retry that request automatically after a failure, no extra guard logic, no "did this maybe already run" check, because the protocol itself guarantees no side effects.
That's a big deal for autonomous agents specifically, more than for a human clicking retry in a browser. A human sees a spinner, waits, decides. An agent doesn't have that judgment call. It either has a rule baked in ("never auto-retry a write") or it doesn't, and if it doesn't, a network blip turns into duplicate side effects that nobody notices until the data's wrong 3 layers downstream.
With QUERY, that rule gets simpler. Not "check whether this is safe to retry." Just "this is QUERY, retry it." The complexity moves from your agent's decision tree into the protocol, where it belongs, and stays there whether the agent's brand new or the one you shipped 8 months ago and haven't touched since.
That's the promise. It's not universal yet, and I'll get to why.
Caching the Reads Agents Repeat
Agents repeat themselves constantly. Same search, same filter, run again 5 minutes later because the agent forgot it already had the answer, or because a different step in the pipeline asked the same question a different way. With POST, every one of those repeats hits the origin server. No intermediary is allowed to cache a POST response, cacheable body or not, because the method itself says "don't."
QUERY changes that math. A cache in front of the API could, once the network catches up, treat 2 identical QUERY requests the way it treats 2 identical GETs: serve the second one from cache, skip the round trip, skip the compute. Even with a complex request body.
Picture the search endpoint your agent hits 40 times a day with the same 3 filter combinations because that's just what the workflow does. Under POST, that's 40 origin hits. Under QUERY, once caching support actually lands where it needs to, that could collapse to a handful. It's the kind of efficiency gain that doesn't show up in a demo, only in a bill.
Funny side note, I still hit cmd+shift+r out of habit before trusting any API response, a tic left over from a caching bug 3 years ago that had nothing to do with HTTP methods and everything to do with a CDN that quietly ignored cache-control headers for 6 months before anyone noticed. Never fixed the reflex. Some habits outlive the bug that caused them.
The APIs Your Agents Already Call
This isn't hypothetical infrastructure for some future agent architecture. It's the exact shape of API most agents already call today: search endpoints, filter endpoints, anything where the query is too complex for a URL but the operation is unmistakably a read. Recommendation engines, product catalogs, log search, anything with facets and ranges and nested conditions.
I went deeper into the token and latency cost of wiring these calls in an earlier piece, and the POST-as-GET pattern shows up constantly there too. It's not a niche annoyance. It's the default shape of how agents talk to search-heavy APIs right now, which is exactly why QUERY's promise lands on ground agents already occupy instead of some hypothetical future use case.
The Wall Most Agents Can't Get Past
This is where the promise runs into the network. The servers can speak QUERY. The problem sits in everything between the agent and the server.
Firewalls, corporate proxies, load balancers, none of them know this method exists yet, because it's 3 months old. Some of them will pass it through without complaint. Others will strip it, reject it outright, or worse, silently downgrade it to something they recognize and mangle the request on the way through. Nothing about the agent is blocking QUERY here. The block sits in every proxy, firewall, and load balancer along the way that doesn't recognize the passport yet.
There's a real security wrinkle buried in this too: if a cache in front of an API doesn't correctly account for the request body when deciding what to cache, you get 1 client's search results served to a completely different client. Same URL, different body, wrong response. That's not a hypothetical, it's flagged directly in the security literature around this RFC as something implementers need to get right before they turn caching on. It's basically the protocol version of "works on my machine," except the machine in question is a proxy somebody's employer bought in 2019 and nobody's touched since.
And the browser story is genuinely unsettled, not just slow. 1 source claims fetch() in the browser can't reliably send QUERY yet as of mid-2026. Another says the opposite, that the Fetch Standard never restricted the method in the first place and browsers already send it fine. I'm not sure which one's right, honestly, and I don't think anyone confidently claiming otherwise has actually tested it across the current browser matrix. Server frameworks are in a similar limbo. Some have proposals in flight, others need you to register the method by hand like it's a custom verb nobody planned for, which, 3 months after ratification, it kind of still is.
Adoption Is Slow. 2 Things Work.
So where does that leave an agent that wants to use this today?
2 places, concretely. First: any stack where you control both ends, client and server, start to finish. An internal API, a tool you built yourself, anything where there's no mystery proxy sitting in the middle deciding what survives the trip.
Second: low-level HTTP clients where you can force the method by hand instead of hoping a framework's abstraction layer supports it. curl does this trivially. So does Rust's http crate, a low-level library that a lot of Rust web tooling builds on top of, which shipped QUERY support in version 1.5.0 in late July, barely 6 weeks after the RFC went final. That's the kind of adoption signal that actually means something (a foundational library moving fast instead of a blog post moving fast).
This is the exact tradeoff calculus agents already make on the MCP side, weighing protocol overhead against what a raw call buys you. Same math, new method. You don't get QUERY for free just because the RFC exists, same as you don't get a clean tool call for free just because MCP exists. Somebody still has to decide it's worth the wiring.
Everything outside those 2 lanes is a timeline nobody agrees on, including the people writing about it professionally. No agent wants to be the HAL 9000 of your pipeline, calmly refusing to retry because nobody told it it was allowed to.
Two things ship today. Everything else is a roadmap somebody hasn't written yet.
I'm not making that bet yet. My agents are still sending POST to a search endpoint and pretending it's fine, same as everyone else's, and I'll switch the day the network stops flagging the passport at the door.
Sources
- RFC 10008, The HTTP QUERY Method, IETF, June 2026
- Hive Security, RFC 10008: The New HTTP QUERY Method and the Attack Surface Still Catching Up
- Developers Digest, RFC 10008: The New HTTP QUERY Method Explained
- http.dev, QUERY: Expert Guide to HTTP Methods
- DEV Community, HTTP Just Got Its First New Method in 20 Years
This post may contain affiliate links. If you click them, I might earn a small commission (costs you nothing, and helps me keep shipping quality articles every day for your reading pleasure).
