Python
Python 3.8+The first client, and the one our own prober runs on.
pip install batchwatchOne first-party client for every language an LLM pipeline
gets written in — and not one of them puts a dependency in
your lock file. Standard library only, all nine. HTTP is
hand-rolled where it had to be (std::net in Rust,
java.net.http, a raw socket in C++) rather than pulling an
HTTP client and a JSON parser into your build.
TypeScript
Node 20+, DenoShips its own types. Two files of source, and no dependencies to install with it.
npm install batchwatchGo
Go 1.21+Installs the way every Go package does - the module proxy already serves it.
go get github.com/batchwatch/client/go@latest.NET / C#
net8.0HttpClient and System.Text.Json, nothing else. Built and tested in CI on every push.
dotnet add package BatchwatchJava
Java 17+java.net.http and nothing from Maven. Kotlin and Scala use it unchanged.
dev.batchwatch:batchwatch-client:0.2.1PHP
PHP 8.2+PSR-4 and stream contexts. No Guzzle, no Symfony HTTP client.
composer require batchwatch/batchwatchRuby
Ruby 3.0+net/http and json from the standard library. No gem dependencies at all.
gem install batchwatchRust
Rust 1.63+std::net only - no tokio, no reqwest, no serde in your dependency tree.
cargo add batchwatchC++
C++17, POSIXA header and a source file, built with a plain Makefile.
git clone https://github.com/batchwatch/client
make -C client/cppsource distributionRead the source →
Or let the agent call us directly
The SDKs put batchwatch in your code. The MCP server puts it in your agent's hands: when a model is deciding "batch this or run it now?", it calls batchwatch and gets the real measured queue evidence — no crawl, no index, no ranking in between. It is the same tier system as the API, so a key earns live figures the same way it does everywhere else.
MCP server
Node 18+Let an AI agent ASK "should I batch this?" and get the real queue evidence — the measured wait distribution, current conditions and a graded confidence — instead of guessing. Six tools, each a real read route, passed through verbatim.
npx batchwatch-mcpTwo lines to adopt, in every one of them
One call before you submit, one context around the job. That is the whole integration, and it is the same shape in all nine languages.
if bw.should_batch("gpt-5.6-sol", max_wait="15m"):
with bw.track("openai", "gpt-5.6-sol", mode="batch"):
submit_the_job()The same three promises, in all nine
- It fails open. Every submission happens off your
thread with a short timeout, and
should_batch()returns your default when we cannot answer. A batchwatch outage cannot stop your job — each client has a test that proves it against a dead port and a hung socket. - It never sends your content. A single allowlist builds the body: provider, model, mode, endpoint, request count, token counts, timestamps, status. Prompts and completions are not sent, not hashed and not sampled, and the test asserts that on what the server actually received.
- It spools to disk. A measurement taken while the network was down is written to a JSONL file and replayed later, in one shared format across all nine — the interesting measurements are exactly the ones taken when things are going wrong.
Open source, and short enough to read before you install it
Every client is MIT-licensed, and the send path is a few hundred lines with no dependencies to chase. That is the point of publishing them: you can check what leaves your machine yourself instead of taking our word for it.