Web3 will be different - ForkLog

# Web3 Will Be Different

For the past few years, the crypto community has been waiting for Web3—where data belongs to users, everything runs on the blockchain, and accessing information requires a crypto wallet.

At the core of the standard vision of the next-generation internet is decentralization. All information is not stored on centralized servers, nor is it used for personalized advertising.

But what if Web3 were a bit different? Let’s look at the world of the future through decentralization enabled by creating your own locally running applications with the help of AI agents.

What People Expect from Web3

With the rise of cryptocurrencies and the development of blockchain technology, many began to see them as the foundation for the next generation of the internet. For example, Tim O’Reilly, the author of the Web 2.0 concept, believes that Web3 can become a significant stage of development if it learns to connect crypto-economics with the real world—including legal systems, ownership, payments, identification, application services, and production.

The crypto community sees the main difference between the new-generation internet and Web 2.0 as deeper decentralization at all levels, including data storage and application operation. Ideally, product development is handled not by the owner, but by a distributed community that manages the project through a DAO.

Decentralization is viewed as a fundamental principle that allowed cryptocurrencies and smart contracts to take their place in the economy: they reduce dependence on intermediaries and centralized structures.

Be Your Own Programmer

The development of large language models (LLMs), AI agents, and vibe-coding makes it possible to look at Web3 differently. ForkLog does not call for abandoning decentralization and blockchain ideas—it’s more about expanding the concept of the future internet.

What if each user becomes their own programmer? Such a user can write applications not for general use, but for personal needs, run them locally on their own computer or on a remote server, and in no way depend on centralized providers.

Let’s take decentralized exchanges like PancakeSwap or Uniswap as an example. They are a set of smart contracts operating on the Ethereum, BNB Chain, and several other blockchains. The networks themselves are decentralized, and access to services is done through non-custodial wallets.

At first glance, that already looks like Web3. However, there remains a point of failure—the frontend. The official websites through which users access exchanges remain centralized: they can restrict certain tokens or block users by IP address and by address.

Getting direct access to smart contracts via the official website is possible, but it’s difficult. You can use third-party frontends, which again brings you back to centralized points, or you can open the contract in a blockchain explorer like Etherscan and call a function through Write Contract. This is inconvenient, complicated, and requires technical skills. Not everyone can handle it.

However, thanks to AI, a third option has appeared: write an application using vibe-coding and run it locally on your PC. We tried to create such a product using Zed, OmniRoute, and LLMs from Anthropic and OpenAI.

Screenshot: ForkLog. The frontend for the project was created via Lovable. When run locally, the application doesn’t yet look as polished and requires interface refinement, but it performs all functions.

Screenshot: ForkLog. The application was built in a few hours of vibe-coding without any knowledge of programming. In the future, AI will become smarter and be able to generate ready-made tools without needing to write dozens of prompts and constantly correcting results. Perhaps it will be enough to just request: “Create and deploy an application for providing liquidity on Uniswap.”

The idea of launching local applications can be developed as far as imagination allows:

• Trading bots for decentralized exchanges—one can write an algorithm that will search for patterns or open trades from a crypto wallet, add chat communication via a Telegram chatbot for convenience and for tracking results;
• Services for using lending protocols—similar to working with DEXs, only in this case the interface will make it possible to deposit funds into Aave, Compound, or Venus and withdraw them in a couple of clicks—on Aave, Compound, Venus, and similar services for earning and borrowing;
• Interfaces for accessing decentralized social networks or censorship-free messengers—at the moment it’s harder to imagine what it will look like in practice, but why not?

Mobile applications are also an area where artificial intelligence can reach. It can easily write not only a website, but also an Android APK file for the same purposes, with direct connection to smart contracts on the blockchain.

Imagine this situation: you find out that Spark offers 12% annual returns on DAI stablecoins. You go to the website, but you’re blocked by IP. Turning on a VPN doesn’t help. In the described Web3 future, that’s not a problem. You open Claude Code and write a prompt:

“Create an application for earning using the Spark protocol on the Ethereum network. Let it be possible to add DAI and withdraw it, and also include a dashboard to track the performance of your investments.”

The AI builds a service that connects directly to smart contracts, bypassing frontend blocks. It runs locally on your PC—no centralized solutions.

Local AI

In such a Web 3.0, the single point of failure could be the artificial intelligence itself—more precisely, centralized language models. ChatGPT, Gemini, and similar solutions run on servers of OpenAI, Google, and other labs. They are capable of filtering traffic, inserting censorship, and imposing restrictions.

However, even in this case there is a solution—open-source LLMs that can be run on your own machine or on a remote server.

For example, you can assemble such a configuration:

• Ollama — runs an LLM locally on a Mac;
• OmniRoute — a router/proxy between Zed and models;
• Zed — an editor that connects to OmniRoute.

As a result, communication in Zed works like in a regular chat-bot: it writes code and launches applications, while the LLMs run locally.

An example of working with AI in Zed to create your own application. Screenshot: ForkLog. Which model to choose depends on your machine’s specs. For example, on a MacBook Air with 16 GB RAM, qwen2.5-coder:7b, qwen3:8b, llama3.2:3b, and deepseek-r1:8b are suitable. On a local server, you can install something more powerful, but that’s no longer the free option.

There are many free, powerful open-source models, but mostly they’re Chinese—DeepSeek, Qwen3.5 from Alibaba, Kimi K2 / K2.5 / K2.6. From American developers, only Meta tried to go in this direction, but the latest LLM was released as closed-source. Google has the Gemma line, but it isn’t a flagship. Still, the neural network is good for local deployment.

In May 2025, Tether announced a new platform for developing “endless and ubiquitous intelligence,” which involves “launching and evolving” AI agents on user devices instead of data centers of large companies.

QuantumVerse Automatic Computer (QVAC) eliminates the need for cloud connection and provides greater confidentiality, autonomy, and resilience. Its modular architecture allows developers to create and expand applications using small composite elements.

A peer-to-peer network ensures direct communication between devices and joint work without relying on centralized servers.

Apple is building AI with an emphasis on local operation on the device—Apple Intelligence. Part of the tasks is performed directly on the iPhone, iPad, or Mac to account for the user’s personal context without collecting personal data. However, for complex tasks the cloud is still used, but its own—Private Cloud Compute. Apple claims that only the relevant part of the data is sent there; after processing, it is deleted. The system is built around privacy.

Open Projects

Besides writing your own code from scratch, you can always use already prepared open-source projects. Fortunately, there is GitHub, where you can find many different implemented ideas.

Here are some projects for managing liquidity:

• Uniswap Interface — the official Uniswap frontend. Supports swaps and liquidity management, but it’s heavy to install and requires environment/API setup;
• Uniswap V3 SDK — the SDK for working with Uniswap V3: price calculations, ticks, ranges, positions;
• Roger-Wu/uniswap-v2-liquidity-adder-contract — a project for adding liquidity to V2 pairs. The description states that the tool allows providing tokens or ETH in any ratio;
• Roger-Wu/uniswap-weth-liquidity-adder — a dapp for adding ETH to Uniswap’s ETH-WETH pool in a single transaction.

When searching for interesting repositories, it’s important to analyze the code, verify contract addresses, and try out their functionality in a test environment or with small amounts. No one guarantees implementation quality.

Ready-made solutions can either be used as-is or adapted to your needs. At the same time, often you don’t need to write code manually—just instruct an AI agent to make the required changes to an existing project.

Screenshot: ForkLog.## Disadvantages

The biggest problem with creating the described Web3 future remains the lack of ready-made, convenient solutions and the technical complexity of implementation. Writing a frontend for decentralized Web3 projects can be done with AI already today, but it’s still difficult for the average user. Without support or hours of analyzing various resources, it’s hard to figure out vibe-coding, installing such tools as Zed or Antigravity, running local LLMs, and connecting them through OmniRoute.

One option is to use ready-made applications from OpenAI (Codex) or Anthropic (Claude Code), but then the idea of decentralization loses meaning, and you would also need to spend significantly on tokens. In the first option, in theory you could code completely for free if you connect several Google accounts to services that provide free tokens.

This is what one of the possible development directions for Web3 might look like:

• everyone writes ready-made applications for themselves using AI, rather than relying on third-party centralized companies;
• everything is stored locally on the device or on a remote server;
• the necessary infrastructure is provided by decentralized blockchains and smart contracts.

It’s still hard to say whether technology development will lead specifically to such a model. It’s possible that Web3 will turn out to be more familiar—without a single control point and with less dependence on large platforms—but with decentralization provided by limited groups of developers. And the users themselves will mostly work with ready-made solutions.