In today’s newsletter:

• Apify: Your Agent Is Only as Good as Its Fetch Layer

• Jev vs LLM Clearly Explained

Reading time: 5 minutes.

Your Agent Is Only as Good as Its Fetch Layer

A research agent can have a strong model, good planning, the right tools, and a solid memory system. But if the next page returns a 403, a Cloudflare challenge, or some other bot protection, the rest of that stack does not really matter.

Search and Fetch Solve Two Different Problems

Search helps the agent find the URL.

Fetch determines whether the agent can actually retrieve the content behind that URL and turn it into something the model can use.

That becomes harder in production because modern websites do more than block suspicious IPs. Bot protection can look at IP reputation, browser fingerprints, JavaScript execution, TLS fingerprints, rate limits, and behavioural signals.

A proxy alone does not necessarily solve all of that.

Where Apify Web Fetch Fits

This is where Apify Web Fetch comes in.

You give it a URL, and it handles things like proxy rotation, browser fingerprinting, JavaScript rendering, challenge handling, and retries before returning the page as Markdown, plain text, HTML, links, or raw content.

That makes it useful inside an agent loop because the output is already in a format the model can work with.

The architecture is pretty simple:

Research Agent → Search → URL → Web Fetch → Page Content → Reasoning

If the fetch step fails, the agent never reaches the part where reasoning matters.

The Benchmark Was Not a Blowout

Apify also recently benchmarked Web Fetch across 384 URLs spanning social media, retail, news, documentation, and synthetic challenges against three other tools.

The important part is not that it was a huge blowout. It wasn't.

Web Fetch had the highest overall success rate in the benchmark, returning 351 of the 384 URLs, while other tools were faster in parts of the latency distribution.

For agent workloads, that distinction matters because getting the page back reliably and getting it back quickly are not always the same thing.

Access Itself Is Infrastructure

This is also why the fetch layer deserves more attention in agent architecture.

We spend a lot of time improving the intelligence above the tool layer. But for agents that work across the open web, access itself is infrastructure.

Read the Web Unblocker Benchmark →

Jev vs LLM Clearly Explained

Stop generating text when all you need is a decision.

Jev is TypeSafe AI's first "System One" model, built for a part of AI systems that we currently keep forcing generative LLMs to handle: making bounded decisions inside software.

Think about what happens during an agent run. The main model may be writing code, researching, planning, or reasoning through a problem, but the system around it is constantly making smaller decisions.

Which model should handle the next step? Does this tool call need approval? Is the agent still making progress? Is the task actually complete?

Today, we often send those questions back to another generative LLM.

Even with structured outputs, the model is still generating tokens sequentially and constraining them into the schema we asked for. The application then takes that generated output and turns it back into the decision it needed in the first place.

Jev removes string generation from that loop.

You give it the current state and define the decisions you care about. Those can be a yes/no judgment, a choice between predefined options, or a score across an ordered scale. Jev returns typed answers with probabilities that the application can use directly.

The Two Side by Side

These figures are TypeSafe's own, published alongside the model.

Giving up string generation is what buys the parallel sampling, the latency, and the free output, and it is also what rules Jev out of every task where the answer is prose.

Where Each One Belongs

Reach for a generative model when the output space is open.

• Writing code, tests, or documentation

• Research, planning, and summarizing

• Explaining why something failed

• Multi-hop reasoning where one step feeds the next

• Arithmetic, counting, and date math

Reach for a decision model when the answer is already one of a known set.

• Yes or no

• Which of these options

• How good, on this scale

• Safe or unsafe

• Continue or stop

• Route here or there

A lot of AI systems currently send both kinds of work to the same LLM, because that is the primitive we already have.

Both in One Agent

Inside an agent harness, those decisions sit everywhere.

A coding agent can use the main LLM to understand a repository and write a fix, while Jev handles model routing, tool gating, risk checks, progress evaluation, or deciding whether another iteration is actually necessary.

And Jev should not become the permission system either. A probability that an action is safe is still a model judgment. Permissions, spend limits, allowlists, and other hard constraints should remain deterministic.

The Separation Is the Point

The interesting architecture is the separation itself: generative models do the open-ended work, decision models handle fuzzy but bounded judgments around that work, and the runtime decides what is actually allowed to happen.

LLM             → does the work
Decision model  → decides how the work proceeds
Runtime         → enforces what is actually allowed

As agents become longer-running, the number of these small decisions only increases.

Using a full generative model for every one of them may turn out to be a very expensive abstraction.

We covered how Jev works in more depth in our previous issue, including the three question types and what the probabilities are actually good for.

That’s all for today. Thank you for reading today’s edition. See you in the next issue with more AI Engineering insights.

PS: We curate this AI Engineering content for free, and your support means everything. If you find value in what you read, consider sharing it with a friend or two.

Your feedback is valuable: If there’s a topic you’re stuck on or curious about, reply to this email. We’re building this for you, and your feedback helps shape what we send.

WORK WITH US

Looking to promote your company, product, or service to 200K+ AI developers? Get in touch today by replying to this email.