EP227: Top 9 Places to Use Jev

EP227: Top 9 Places to Use Jev - ByteByteGo Newsletter

EP227: Top 9 Places to Use Jev

ByteByteGo

Sep 26, 2026

[Webinar] How to stop babysitting your agents (Sponsored)

Agents can generate code. Getting it right for your system, team conventions, and past decisions is the hard part. You end up wasting time and tokens in the correction loops.

More MCPs, rules, and bigger context windows give agents access to information, but not understanding. The teams pulling ahead have a context layer to give agents exactly what they need for the task at hand.

Join us for a FREE webinar on Oct 7 to see:

• Where teams get stuck on the AI maturity curve and why common fixes fall short

• How a context layer solves for quality, efficiency, and cost

• Live demo: the same coding task with and without a context layer

If you want to maximize the value you get from AI agents, this one is worth your time.

Register now

This week’s system design refresher:

• Top 9 Places to Use Jev

• LLM, RAG, AI Agent & Agentic AI

• Ex-YouTube Engineer Rebuilds YouTube in 45 Mins (Youtube)

• MCP vs Function calling

• If Claude Code is a burger...

• Rebuild Youtube Live Course Start Today

Top 9 Places to Use Jev

Jev is TypeSafe AI’s first System One Model. It is 100x faster and cheaper than frontier LLMs.

That opens up a lot of use cases people usually skip because the big models are too slow or too expensive for them.

Here are the top 9 places to use Jev instead of an LLM:

• Model routing. Jev takes the prompt as input and routes it to a proper LLM.

• Guardrails. Detect security risks in the prompt first. Then pass it to the LLM.

• Gating tool-calls. Classify agent tool calls into one of their permission categories.

• Triage inbox. Classify lots of emails into categories (e.g., spam, urgent, archive).

• Reranking. Score passages against a query (prompt) so we can rank them by relevance.

• LLM evals. Evaluate an LLM’s output and return a score within a range.

• Bulk labeling. Label lots of rows from a huge table fast and cheap (map-reduce style).

• Real-time decisions. Use cases where a fast decision is needed in a loop (e.g., trading).

• Confidence gate. Classify anything based on confidence and act properly.

The bottomline is to use the LLM for generations and use Jev on the decisions around it.

What are other places to use Jev instead of an LLM?

LLM, RAG, AI Agent & Agentic AI

LLM: An LLM takes a user prompt and generates a response from its learned parameters. It does so by predicting tokens one at a time.

RAG: In RAG, the user query goes to a retriever before the LLM. The retriever fetches relevant information from the indexed knowledge base and passes it to the LLM along with the query. The LLM generates a grounded response, but it does not guarantee correctness.

AI agent: It has a goal and keeps track of the current task state. It can plan about what to do next, call tools, get a result back, observe it, and repeat until the goal is met. This feedback loop allows the agent to observe the results and adjust its actions accordingly.

Agentic AI: Putting one or more AI agents to meet a shared objective is what makes an AI system agentic. It is achieved through planning, tool use, and feedback. You add an orchestration layer, which coordinates work across multiple agents and workflows. Agents read and write to shared task states and can access tools, data, and the environment.

Ex-YouTube Engineer Rebuilds YouTube in 45 Mins

MCP vs Function calling

MCP and function calling have a lot in common. This confuses a lot of engineers, so here is a side-by-side comparison.

Both MCP and function calling are mechanisms that allow an LLM to have access to tools. The agent runtime sends the prompt to the LLM, the LLM decides which tool to use and emits a tool call request.

The agent runtime then handles tool call execution and returns the results back to the LLM to continue. The LLM finally produces a final output shown to the user.

What is different between the two is where the function is implemented, and how the agent handles the execution. In local function calling, the functions are implemented locally on the user's machine. The agent runtime executes them and receives the results.

In MCP, the functions can be outside of the user's machine, on some remote server. The agent runtime follows the MCP protocol and calls the corresponding server, the execution happens remotely, and the results are sent back to the agent runtime.

This allows your agent to connect to hundreds of thousands of tools that are implemented publicly and hosted remotely.

Over to you: What are the best MCP resources out there?

If Claude Code is a burger...

Before each model call, Claude Code assembles a context window from 9 distinct sources.

Think of it as a burger, each layer adds something different.

• System Prompt: Defines Claude's role, behavior, and tone. This sets the foundation.

• Environment Info: Git status, branch info, and current date. Pulled in via getSystemContext()

• CLAUDE.md: A four-level instruction hierarchy: managed → user → project → local. Plain-text Markdown, so users can read, edit, and version-control everything the model sees.

• Auto Memory: Contextually relevant memory entries prefetched asynchronously. An LLM scans memory-file headers and surfaces up to 5 relevant files on demand.

• Path-scoped Rules: Conditional rules that load lazily when the agent reads files

• Tool Metadata: Skill descriptions, MCP tool names, and deferred tool definitions.

• Conversation History: Carried forward across iterations.

• Tool Results: File reads, command outputs, and subagent summaries.

• Compact Summaries: When history grows too long, older segments are replaced by model-generated summaries.

Rebuild Youtube Live Course Start Today

Rebuild YouTube with AI, taught by a former YouTube engineer, kicks off on Saturday, September 26. Enrollment closes in 24 hours .

Check it out Now →

What you will learn

• Scope a realistic MVP. Decide which YouTube features to build and break the work into manageable tasks.

• Work with agents. Plan changes, review generated code, and recover from bad diffs or sessions that go off track.

• Build across the stack. Turn mockups into React pages and build a backend with Postgres, authentication, and video uploads.

• Add semantic search and related videos. Use multimodal embeddings and understand how this approach differs from production recommendation systems.

• Test and deploy your app. Check features with Playwright, deploy to Vercel, and track watch time in an admin dashboard.