Jeremy Chone spends nearly three hours refactoring sysone, his unofficial Rust client for TypeSafe AI’s Jev API. The useful artifact is real: the session ends by testing, tagging, and publishing crate version 0.0.3.

I inspected the current repository and its request, response, answer, key, and pricing tests. I could not run the suite because Rust/Cargo is not installed on this host, and I did not make a live paid Jev call. This is an implementation inspection, not a security audit or model-quality evaluation.

The API shape he is wrapping

  • Jev receives a state plus one or more bounded questions.
  • noul represents a binary condition, choice selects among named criteria, and score returns an ordinal result.
  • The service returns probabilities and typed answers rather than prose.
  • Chone keeps state and criteria open to arbitrary JSON because the upstream API accepts structured values.
  • He says the service had a 32K-token input limit and at most 255 criteria at recording time; those are presenter-reported limits, not independently reproduced here.

What changes during the stream

  • Typed responses: raw serde_json::Value output becomes a Response with model, token usage, optional client-computed cost, and typed answers.
  • Stable question keys: QKey accepts a name or numeric index, with indexed keys serialized as q0, q1, and so on.
  • Typed questions: NoulQuestion, ChoiceQuestion, and ScoreQuestion encode the three upstream forms without closing off raw JSON escape hatches.
  • Fluent construction: requests can append or extend questions; choice and score questions can append criteria or levels.
  • Examples and tests: he adds a multi-choice example, runs Cargo checks during the session, updates the README, tags v0.0.3, and publishes it to crates.io.

The live work is valuable precisely because it includes corrections. An initial AI-generated refactor mishandles collections of criteria; Chone stops, revises the goal, and makes every question type support the required list shape. He also catches a Rust array inference issue and rewrites the example rather than treating generated code as finished.

Keep the typing at the boundary

Chone’s design compromise is sensible for an evolving API:

  • strongly type the stable discriminators and response variants;
  • preserve arbitrary JSON where TypeSafe explicitly allows strings, arrays, or objects;
  • expose both ergonomic constructors and a raw-value conversion path;
  • keep pricing optional because a local or alternative backend may not report a billable cost.

That is more robust than mirroring every observed payload field into a rigid Rust type and then breaking whenever the upstream service changes.

The claims need boundaries

  • The live French example shows that one request returned a plausible result; it is not a multilingual benchmark.
  • Successful serialization and a typed response prove API plumbing, not decision accuracy.
  • Chone questions TypeSafe’s price comparison and notes that cheap LLMs can also perform bounded classification. He does not run a matched cost, latency, or quality study.
  • The repository calls itself a very early 0.0.x release and invites users to cherry-pick rather than treat the API as stable.
  • crates.io records version 0.0.3 as 1,173 lines of Rust across 16 files, but code volume is not evidence of reliability.

“It’s overhyped, but it’s not because something is overhyped that it is not going to get used.”

The more interesting future use case

Near the end, Chone connects Jev to agent tool selection. His ai-prog approach gives a language model roughly 150 callable functions and asks it to write a sandboxed Lua program. Instead of placing every function definition in every generative prompt, a fast decision model could first select the small subset relevant to the task.

That remains a proposal, not an implemented benchmark in this video. Still, it is a concrete Jev-shaped problem: frequent bounded routing in front of a slower open-ended model.

Takeaway

The stream is not an evaluation of whether Jev makes correct decisions. It is a detailed record of turning a raw HTTP contract into a usable Rust boundary while the upstream API is young.

The durable lesson is to separate three claims:

  1. the crate can serialize requests and parse typed responses;
  2. Jev returns a valid answer of the requested shape;
  3. the answer is correct enough for the product.

The session materially demonstrates the first, spot-checks the second, and does not establish the third.