Gonka gave a lecture at Berkeley: what did students ask about decentralized AI?

Gonka co-creators Anastasia Matveeva and Gleb Morgachev spoke about Gonka as a decentralized AI compute protocol — why it exists, what problems it addresses, what decentralized inference looks like, and why compute verification matters.
At the beginning of the lecture, the speakers said they wanted to have a broader discussion — not necessarily focused entirely on Gonka itself, but on decentralization in AI in general.
They were particularly interested in open engineering and research questions that remain unsolved and are still being explored.
The Gonka representatives also said they hoped some of these problems might interest the students and encourage them to take part in the research.
Why decentralize AI?
Anastasia and Gleb started with a basic question: why consider AI decentralization at all?
“I think being in Berkeley in 2026, you probably don’t want to hear another speech about how AI is becoming a more and more important part of our lives. But it does affect our lives. It affects the speed of progress. It affects who can do research and who can generate new results with this research. So I’d say that access to frontier models is pretty important,” says Anastasia.
According to her, when it comes to closed models, the situation is fairly straightforward: whoever controls the model also controls access to it and, to some extent, its output.
“Who controls the model controls access to it and also controls the output. So what can be produced by this model? Is it censored in any way? Is there any advertisement injected into it? Or maybe is it adjusted to serve some propaganda?
What would be an alternative? One obvious thing that’s been discussed a lot lately is open-weight models.”
Anastasia believes open weights solve some of these problems, but control then largely shifts from model owners to those who own the compute.
“Open-weight models do solve some of these issues, but they rather shift control from those who own the models to those who own the compute. If you don’t have access to compute to run your model, it doesn’t matter that the weights are open.
If that open-weight model is being served on hardware that you don’t have access to, you’re just getting it from some provider who is claiming to serve that open-source model. You actually have no control over understanding whether the model was modified, whether the outputs you’re getting were adjusted, or whether you got, for example, a quantized version that produces much lower-quality results and the provider never tells you about it,” says Matveeva.
Gleb Morgachev, in turn, pointed to the huge amount of computing hardware already distributed among many independent owners.
“Bitcoin miners together operate more than 26 gigawatts of data centers. The new AI data center Colossus 2 is only about one gigawatt. So the amount of compute capacity collected together in Bitcoin is just huge. It’s more than OpenAI has. It’s more than Meta has,” he says.
If a similar principle were applied to AI hardware, distributed compute could be used for useful work — running inference and training models. Such a distributed system also has another important property: restricting access to its compute is extremely difficult.
“What is also cool about this is that it’s almost impossible to somehow limit access to such compute capacity. You can tell OpenAI not to serve models to some people, and they will have to not serve them.
But when it’s a distributed network, it’s thousands of different companies in different places. Some companies are fully anonymous, and no one even knows who they are. You block one small data center, but Bitcoin will not change from this,” Morgachev says.
What does Gonka want to do about this?
In response to a question from one of the students, Gleb explained that, unlike Bitcoin, a decentralized AI network has much more demanding hardware requirements.
Such a system must be able to serve the best open-source models fast enough, remain self-sufficient, and avoid depending on a single party that could restrict access or alter model outputs.

Gonka’s framing of decentralized machine learning: distributed hardware, open participation and trustless operation.
“The hardware will be distributed around the world. It’s different servers, with really poor connection over the internet instead of NVLink. The hardware will also be heterogeneous — CUDA, AMD, some custom accelerators — and we cannot predict which hardware it will be.
To gather together a lot of hardware, we must allow everyone to join such a network and contribute their hardware. So it should be permissionless. But when we allow anyone to join, not everyone will be honest. So such a system also must be trustless. It must not just assume that the hardware provider will be honest,” he says.
How do you build trust in a system where nobody can be trusted?
According to the Gonka team, this creates an apparent contradiction. On the one hand, the network needs reproducibility and verifiability. On the other hand, anyone participating in the system may potentially try to cheat.
How can the network decide what to trust if it cannot trust individual participants?
“It’s a well-known problem from game theory — Byzantine generals. The formulation is about generals deciding whether to storm or not to storm a city. The majority are loyal, but a small group are traitors trying to get them to follow a plan that will get them all in trouble.
How would you solve such a problem? All of the strategies rely on the assumption that a majority of those generals would be honest. Similarly, all decentralized systems are based on this honest-majority assumption,” explains Anastasia Matveeva.
In Byzantine fault tolerance, the usual assumption is that two-thirds of validators are honest. Gonka is based on a similar principle.
“When launching Gonka, the mechanism we adopted — Proof of Compute — is a version of Proof of Work where the weights are proportional to computational capacity benchmarked by model inference.
The key point is that it doesn’t produce any significant amount of useless work. The benchmarking phase is very short and is used to understand the capacity. For the rest of the time, the system serves inference of the open-source models that participants agree upon,” notes the Gonka co-creator.
Proof of Compute and the security model
According to Gleb Morgachev, the purpose of Proof of Compute is to assign each participant a weight proportional to their computing capacity.
The network is not interested in abstract compute capacity — for example, how many hashes a device can calculate per second. What matters is performance relevant to large language model inference. This includes not only raw compute and low-precision operations, but also memory bandwidth, because LLMs need to read data from VRAM quickly.
How does it work?
“Once an epoch, Proof of Compute has two phases. First, all hosts generate artifacts simultaneously — it’s really important that they do this at the same time. These artifacts are based on a forward pass with randomly seeded input of a large language model.
For a couple of minutes, each host produces as many artifacts as it can. Then every host starts validating others: they sample a random subset of artifacts from other hosts, repeat the computation, and validate whether it was honest or dishonest.
Then they vote and decide on the weight of that host for the next epoch. This procedure takes around three minutes, and everyone agrees on the weights for the next 24 hours,” he says.

Proof of Compute sets host weights, assigns work and links rewards to valid execution.
How the network distributes work
As Gleb explained, once Proof of Compute is complete, a host’s weight is used to distribute real tasks across the network. If one host has ten times more weight than another, it receives roughly ten times more work. This is not synthetic work created only to support the protocol. These are real user inference requests and potentially other AI tasks.
“It’s a real task, not an artificial task. Someone goes to Gonka and says, ‘I want my agent to work on some model,’ and this is actually a task.
The host must execute all these tasks to be rewarded, and they are rewarded at the end of the epoch only when all the work is done,” Morgachev explains.
This creates another problem: the network needs to verify that a host actually processed a request using the model it was supposed to use. Simply sending the same prompt to another server is not enough. GPU computations are non-deterministic, while recomputing every request would make the system too expensive. The network therefore verifies only a random subset of inference requests. A validating host repeats the necessary computation for an already known token sequence and compares the resulting probability distributions with the original result.
“What we actually use in practice now is that the system verifies not all requests, but only a small subset. Each host samples requests from another host to decide whether it should verify them.
For such a request, it repeats the inference with the sequence of tokens known in advance, gets the log probabilities for that same sequence, and compares the artifact with the original artifact. The host then decides whether it thinks the inference was valid or invalid.
Actual voting happens only when some host wants to invalidate another host,” says Gleb.
The network is not trying to judge whether an answer is “good.” Its goal is to determine whether the host actually used the model it claimed to use. For example, if a host is expected to serve a model in FP8 but switches to an FP4 version to save resources, the inference should be considered invalid.
In addition to checking individual requests, Gonka also needs to verify that a host is actually providing the amount of compute it claimed. The network can monitor whether the host handles its assigned workload and responds on time. A participant that repeatedly fails to do so may lose its reward for the epoch.
Why one blockchain was not enough
Another challenge that the Gonka team initially underestimated was scalability. Even a few thousand GPUs can process a huge number of requests. At the same time, a decentralized system needs to record payments, request starts and completions, validation results, and votes.
“When we started this protocol, we didn’t really think scalability was so important, but then it became quite painful. Even if you have a couple thousand GPUs used for inference, you need to record millions of transactions to the network just for voting and billing — a request started, a request finished, and so on.
As it turned out, no decentralized protocol can process so many transactions this way,” Morgachev says.
One of Gonka’s solutions is a system of small, temporary decentralized networks created for individual interactions with the protocol.
“When a user wants to interact with the protocol and use inference, they create an escrow and open a small independent decentralized network — a small independent blockchain that lives only for the next couple of hours.
If we have a thousand users, it’s a thousand small temporary blockchains. This can scale linearly, and it works pretty well,” says Gleb.
Can models be trained over the internet?
After discussing inference, the Gonka co-creators moved on to a longer-term challenge — distributed model training. Anastasia noted that running a model may require only a few GPUs, while training a model of the same scale traditionally requires a much larger number of accelerators located in the same data center and connected by high-speed networking.
“How can we do this without having a huge data center, without having this ultra-fast interconnect between GPUs sitting in that data center, and yet achieve comparable performance and not lose on the resulting model quality?
How can we make training over the internet possible? It’s a big, interesting, open research question,” says Matveeva.
One of the approaches discussed during the lecture was DiLoCo — Distributed Low-Communication Training from Google DeepMind. The basic idea is to synchronize the results of different participants much less frequently: part of the training is performed locally, while the results are periodically aggregated.

DiLoCo was discussed as one approach to training across geographically distributed hardware.
“In the DiLoCo paper, they explored an approach of reducing those communication steps and splitting the process into a training loop where you have an inner optimizer used locally for every participant, and much rarer steps when you actually aggregate the steps that everybody computed separately.
So you’re parallelizing the training, but you still have these steps covering everybody. The results show that the quality of models produced in such a way actually hits the benchmarks of models of a similar size trained in a centralized, co-located way,” Anastasia explains.
According to the Gonka representatives, this direction is already being tested in practice by other teams. Prime Intellect was among the projects they mentioned. For a decentralized network, it is also important that the set of participating GPUs does not necessarily have to remain the same. A participant can contribute to part of a training run and then leave, while other participants continue the process.
How do you train a model when some participants cannot be trusted?
As the Gonka co-creators emphasized, distributing training over the internet solves only part of the problem. In a trustless system, you cannot simply assume that every participant is honestly performing the computation it claims to perform. The consequences are potentially more serious than with a single inference request: malicious or incorrect updates can affect an entire training run.
According to Anastasia, the goal of Byzantine-tolerant training is not necessarily to identify every malicious participant. The more important objective is to make sure the model can continue to converge even when some updates are bad.
“The goal is not just to find those participants or avoid incorrect submissions completely, because that would also be impossible. The goal is to make sure that eventually your model converges to what it would converge to in the honest case regardless.
Even with some percentage of potentially malicious or randomly incorrect updates, the honest ones should continue to improve the model and get it towards convergence, while the faulty updates should not dominate the aggregation process,” she says.
This remains an open research problem. Participants need to be verified often enough to protect the training process, but not so often that the additional computation makes distributed training inefficient. The speakers also noted that technical verification is only part of the picture: economic incentives — rewards and penalties — can affect whether cheating makes sense for participants.
What if we use many small models instead of one huge model?
At the end of the main part of the lecture, the Gonka team discussed another research direction: using many smaller models that interact with each other instead of always trying to build one very large model. One approach is for smaller models to exchange not only text, as AI agents usually do today, but also their internal states. For decentralized AI, this is particularly interesting because it could significantly reduce the hardware requirements for individual participants.
“All these things are important for the decentralized world because, once there are good results both in training smaller models that interact and in inference of such models, you can use not only data-center-grade hardware in a decentralized network — you can really use your phone.
If a one-billion-parameter model becomes really valuable when interacting with thousands of other one-billion-parameter models, cool computation can happen in our pockets. I think that’s one of the big goals for how this can become truly decentralized,” says Gleb.
At the end of the main presentation, the co-creators emphasized that many of the areas they discussed are still open research problems. At the same time, the discussion was not purely theoretical: inference is already running, and the distributed training runs mentioned during the lecture have actually taken place.
Questions from Berkeley students
What is an artifact in Gonka’s Proof of Compute?
An artifact is used in Proof of Compute to verify that a host actually performed the required computation. A nonce — an integer value — is used to define the model input. During the computation, several small random layers are added to the LLM, together with an additional random linear layer at the output. The resulting artifact is a small multidimensional vector. Together with the input nonce, it allows the network to verify the computation end-to-end.
The challenge is that GPU computations are non-deterministic, especially across heterogeneous hardware. The same computation cannot simply be repeated with the expectation of getting an exactly identical result. That is why verification has to be statistical: artifacts are compared using a metric that helps determine whether the result is valid.
How are random parameters selected for verification?
The starting seed comes from the hash of the block that triggers the Proof of Compute procedure. To generate the final seed for a particular host, its public key and nonce are added. By the validation stage, these seeds are known.
A validator can, for example, select 100 artifacts out of 10,000, request the full artifacts from another host, and repeat the relevant computation.
Why does Proof of Compute use random layers?
These are small additional layers that are not used by the model outside Proof of Compute. They make it more difficult for a participant to optimize specifically for the benchmark or replace the full model with a smaller distilled version. The randomization therefore acts as an additional security layer.
How is user data protected?
In the current architecture, the server performing a user’s inference can technically access data stored in its memory. The same can apply to another host if it needs to repeat the request as part of validation. The protocol developers themselves do not automatically get access to user data unless they are also operating a host.
One potential solution mentioned by the Gonka representatives is a trusted execution environment (TEE), which can protect data even from the server operator. Another option is to use publicly identifiable corporate hosts that can make contractual commitments regarding data storage and deletion.
How can distributed training be protected from dishonest participants?
There is currently no complete Byzantine-tolerant mechanism for training on the network. During the testnet, the team experimented with Proof of Learning. Hosts had to save the results of some randomly selected gradient steps, which could later be requested and recomputed by another participant.
The approach made it possible to detect hosts that were not actually performing the work, but it required storing very large amounts of data. The speakers described it as theoretically attractive but not yet practical.
Why is inference on Gonka currently so cheap?
Host rewards currently come from two main sources: rewards generated by the protocol itself and payments from users for inference. At this stage, protocol rewards are much larger than user fees. In other words, users are not yet paying enough to fully cover the cost of the hardware provided by hosts. A significant share of host compensation comes directly from the protocol for contributing compute capacity.
The team also originally considered dynamic pricing: prices would increase when network utilization became high and decrease when the network was underutilized, helping balance demand and available compute. According to the speakers, this mechanism is not currently running on-chain.
How can Gonka deal with regulatory requirements?
One student raised a scenario in which legislation requires an AI provider to block certain categories of requests. The Gonka representatives pointed to a fundamental difference in a decentralized network: there is no single inference provider. The network consists of independent hosts operating in different countries, each of which may need to follow its own local regulations. If a company resells Gonka inference in a particular country, it could implement the required restrictions at its own service layer.
If a rule were meant to apply to the entire network, it would become a governance issue: participants would need to agree on the change and update the software or models accordingly. At the same time, Gonka’s current validation system does not analyze the content of user requests. Its purpose is to verify that the host actually used the model it claimed to use.
Why is the project called Gonka?
The name comes from the Russian word “гонка,” which means “race.” The speakers explained that there are many Russian-speaking people on the Gonka team, and that the name also reflects the idea behind Proof of Compute. In a sense, participants are racing to optimize their hardware — tuning it for a particular model and trying to serve inference as efficiently as possible.
So “Gonka” refers not just to the Russian word itself, but also to the competition around hardware optimization built into the Proof of Compute mechanism.
Your support helps keep the blog independent
It helps us spend more time on analysis and original stories about the network.