Forem: Ying

How GenLayer Contracts Read the Web: A Beginner's Guide to Non-Deterministic Blocks

Ying — Mon, 18 May 2026 12:00:50 +0000

Smart Contracts That Can Browse the Internet

Imagine a smart contract that can check a sports score, verify a news headline, or read a product price all on-chain, with consensus. Traditional smart contracts are blind to the outside world. They can only work with data that's explicitly fed to them through oracles or manual transactions.

GenLayer changes this. Its Intelligent Contracts can fetch live web pages and call LLMs directly, then reach agreement among validators on what the result means. This article walks you through how that works, starting from zero.

What Makes This Possible: Non-Deterministic Blocks

The core challenge is simple: if a contract fetches a web page, two validators might get slightly different results (ads change, timestamps shift, content updates). Traditional blockchains can't handle this they require every node to produce the exact same output.

GenLayer solves this with non-deterministic blocks special Python functions where web fetches and LLM calls are allowed. After each validator runs the block independently, GenLayer's consensus mechanism (the Equivalence Principle) determines whether the results are "close enough" to agree on.

Here's the mental model:

Deterministic code → same input, same output (like normal smart contracts)
Non-deterministic block → validators may get different raw results
Equivalence Principle → validators agree on whether results are equivalent

Your First Web-Reading Contract

Let's build a contract that checks whether a webpage contains a specific link. This is the simplest possible example of web connectivity:

# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" }

from genlayer import *

class WebChecker(gl.Contract):
    has_link: bool

    def __init__(self, url: str, keyword: str):
        target_url = url
        target_keyword = keyword

        def check_page():
            web_data = gl.nondet.web.render(target_url, mode='html')
            return target_keyword in web_data

        self.has_link = gl.eq_principle.strict_eq(check_page)

    @gl.public.view
    def result(self) -> bool:
        return self.has_link

Let's break down what's happening:

The version comment on line 1 pins the GenVM runtime version (like Solidity's pragma)
gl.nondet.web.render() fetches a live web page inside the non-deterministic block
gl.eq_principle.strict_eq() tells validators to compare results with exact equality — if all validators get True, consensus passes

The Rules of Non-Deterministic Blocks

There are a few constraints that keep the system safe:

No storage access you cannot read or write contract state inside a non-deterministic block
No side effects leak out changes to Python globals inside the block don't persist
Web calls must happen inside an equivalence principle call calling gl.nondet.web.render() outside of gl.eq_principle.* will throw an error
The block is a zero-argument function it captures variables from the surrounding scope via closure

Think of it like a sandbox: the contract says "go look at the world and tell me what you found," then validators compare notes.

Choosing the Right Equivalence Method

GenLayer offers different ways for validators to agree:

Method	Use When
`gl.eq_principle.strict_eq()`	Result is a simple value (bool, number) where exact match makes sense
`gl.eq_principle.prompt_comparative()`	Result is text/complex data where an LLM should judge equivalence

For our web-checker example, strict_eq is perfect we're returning a boolean. But if you were summarizing a news article, you'd use prompt_comparative so validators can agree that two slightly different summaries convey the same meaning.

A Practical Example: Price Threshold Monitor

Here's a slightly more useful contract it checks whether a product page shows a price below a threshold:

# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" }

from genlayer import *

class PriceMonitor(gl.Contract):
    item_url: str
    threshold: str
    is_below_threshold: bool

    def __init__(self, item_url: str, threshold: str):
        self.item_url = item_url
        self.threshold = threshold
        self.is_below_threshold = False

    @gl.public.write
    def check_price(self):
        url = self.item_url
        limit = self.threshold

        def fetch_and_compare():
            page = gl.nondet.web.render(url, mode='text')
            prompt = f"Extract the main product price from this page and tell me if it is below {limit}. Answer only YES or NO.

Page content:
{page}"
            result = gl.nondet.llm.call(prompt)
            return result.strip().upper() == "YES"

        self.is_below_threshold = gl.eq_principle.strict_eq(fetch_and_compare)

    @gl.public.view
    def below_threshold(self) -> bool:
        return self.is_below_threshold

This combines both web fetching and LLM reasoning inside a single non-deterministic block. The LLM extracts the price and makes the comparison, then validators agree on the boolean result.

Key Takeaways

GenLayer contracts can read live web data no external oracle infrastructure needed
Non-deterministic blocks are sandboxed functions where web and LLM calls happen, isolated from contract storage
The Equivalence Principle handles consensus validators independently execute the block and agree on results
strict_eq works for simple values, while prompt_comparative handles fuzzy text comparison
You write everything in Python no new language to learn, just a few GenLayer-specific patterns

Next Steps

Ready to try this yourself? Head to GenLayer Studio it's a zero-setup web IDE where you can write, deploy, and test Intelligent Contracts in your browser. No Docker, no local install needed.

For a full local development environment with testing and linting, check out the GenLayer Project Boilerplate and the official documentation.

From Zero to GenLayer: A Beginner's Mental Model for Trustless Adjudication

Ying — Thu, 14 May 2026 13:25:35 +0000

From Zero to GenLayer: A Beginner's Mental Model for Trustless Adjudication

A beginner-friendly guide to understanding why GenLayer introduces Intelligent Contracts for decisions that need judgment.

Why GenLayer matters

If you are new to GenLayer, the simplest way to start is to compare it with earlier blockchain ideas.

Bitcoin made trustless money easier to reason about. Ethereum expanded that idea into trustless computation. GenLayer presents itself as the next layer in that progression: trustless adjudication.

That word sounds formal, but the core idea is practical. Some applications do not only need code to execute fixed rules. They need a way to resolve situations that involve judgment, natural language, unstructured data, or live web inputs. GenLayer is designed for that category of problem.

1. What "adjudication" means here

In traditional software, many decisions are handled by a central service, a company policy, or a human reviewer. In deterministic smart contracts, logic is usually written as precise code: if this condition is true, do that action.

GenLayer focuses on the cases where the decision is not so simple.

The documentation describes GenLayer as "The Adjudication Layer for the Agentic Economy." It is built for disputes or decisions that require judgment, not just deterministic execution. Instead of treating every outcome as a basic code path, GenLayer uses decentralized AI-validator consensus to resolve judgment-based contracts.

For a beginner, the useful mental model is this:

deterministic computation asks, "Did the code conditions pass?"
adjudication asks, "What is the correct judgment based on the available context?"

GenLayer is aimed at the second question.

2. Intelligent Contracts are the core building block

GenLayer's core contract model is called an Intelligent Contract.

According to the documentation, Intelligent Contracts can work with natural language, unstructured data, and live web inputs. That matters because many real-world and agentic-commerce workflows do not fit neatly into a fully deterministic input/output box.

For builders, this changes how you think about contract design. You are not only writing code that checks fixed values. You are designing a contract around a decision process that may need context.

That does not mean inventing facts or ignoring rigor. It means the contract model is meant for a different class of application: applications where judgment is part of the workflow.

3. How GenLayer fits into the broader blockchain stack

The docs frame GenLayer in a progression:

Bitcoin: trustless money
Ethereum: trustless computation
GenLayer: trustless adjudication

This is a helpful starting point because it avoids treating GenLayer as "just another chain" or "just AI plus Web3." The more precise idea is that GenLayer focuses on a missing dispute-resolution or decision layer for applications in the agentic economy.

The docs also mention related agentic-commerce infrastructure efforts around payments, identity, interoperability, and agent payment protocols. GenLayer's role is described around judgment-based contracts and adjudication.

So the beginner takeaway is: GenLayer is not replacing every previous blockchain primitive. It is trying to add a layer for a specific kind of problem.

4. What builders can do first

The documentation gives several onboarding paths:

Discover the Protocol
For Developers
For Validators

For developers, the docs say builders can build Intelligent Contracts in Python and deploy them to testnet or GenLayer Studio. For validators, the docs point to running validator nodes and participating in the GenLayer network.

The docs also recommend GenLayer Skills as a quick onboarding route for building contracts or running a validator. GenLayer Skills is described as a Claude Code plugin that can scaffold, deploy, and operate workflows.

That gives beginners two practical tracks:

Learn the protocol concepts first, especially Intelligent Contracts and adjudication.
Try the developer or validator path depending on whether you want to build contracts or operate infrastructure.

5. A practical analogy

Imagine a simple vending machine. If you insert enough money and press the right button, the machine releases the item. That is deterministic logic.

Now imagine a marketplace dispute where two autonomous agents disagree about whether a delivered result satisfies a natural-language request. The answer may depend on context, interpretation, and evidence. That is closer to an adjudication problem.

GenLayer is designed for the second style of workflow: decisions where judgment matters and where the application needs a trustless way to resolve that judgment.

Takeaways

GenLayer describes itself as the adjudication layer for the agentic economy.
Its core building block is the Intelligent Contract.
Intelligent Contracts are designed to work with natural language, unstructured data, and live web inputs.
A useful beginner framing is Bitcoin for trustless money, Ethereum for trustless computation, and GenLayer for trustless adjudication.
Builders can start by exploring the protocol, developer path, validator path, or GenLayer Skills.

Where to go next

If this mental model makes sense, the next step is to read the GenLayer docs and explore the GenLayer portal or developer materials. Start with the protocol overview, then move toward Intelligent Contracts and the builder path that matches what you want to contribute.

Sources

GenLayer Documentation Homepage: https://docs.genlayer.com/