Why Local Models Beat Jev AI API in Doom Game Decision-Making

In the practice of AI game agents, latency is often the decisive factor between victory and defeat. Recently, a YouTube creator compared the performance of a local model, GLiNER, against a hosted API (Jev AI) in the Doom game environment, and the results are thought-provoking: the local model not only responds faster but also achieves a decision frequency that is several times higher.

Latency: The Divide Between Local Models and APIs

The video author explicitly points out that the latency difference between using an API and a local model has a huge impact. GLiNER runs entirely locally, with a response time of only 12 milliseconds, enabling it to react instantly to changes in the game. In contrast, Jev AI, as a hosted service, requires a network round trip, resulting in significantly higher latency.

This latency difference directly affects the decision quality of the AI agent. In the fast-paced game of Doom, every millisecond matters. A local model can perceive the environment and take action more quickly, while API calls may miss the optimal timing.

Network round-trip time (RTT) is the key concept for understanding this comparison. When a client sends a request to a hosted API, the data must travel over the public internet to the provider's data center, complete inference, and then return the result. This process involves at least one full round trip, with physical distance, routing hops, and congestion conditions all adding to the time. Even if the provider is in the same city, RTT is typically in the range of 10-50 milliseconds; cross-region calls can reach 100-300 milliseconds. For a game agent that needs to make multiple decisions per second, this overhead accumulates serially with each call, whereas local inference only bears the time of the model's forward computation—the 12-millisecond response comes almost entirely from computation itself.

Inference latency and throughput are also worth distinguishing: latency refers to the time from sending a single request to receiving the result, while throughput refers to the number of requests that can be processed per unit time. Game agents require both low latency and high decision frequency, because the agent needs to complete perception and action selection within each game tick. Hosted APIs often improve throughput through batching, but this further increases single-request latency; small local models can perform inference directly on a single sample, making them naturally suited to this "low-latency, high-frequency" workload pattern.

Decision Frequency: 8.8 per Second vs 2.5 per Second

According to the data in the video, GLiNER can make 8.8 decisions per second, while Jev AI, limited by its hosted service, can make only 2.5 decisions per second. This means the local model's decision frequency is more than 3 times that of the API.

A higher decision frequency allows the AI agent to control the game character more finely and respond to emergencies in a timely manner. In a first-person shooter like Doom that requires quick reactions, this advantage is particularly evident.

GLiNER is a class of lightweight information extraction models based on a bidirectional encoder architecture, designed to perform structured tasks such as entity recognition with a smaller parameter count without relying on the generative capabilities of large language models. It transforms named entity recognition into a matching problem between "text spans and entity types," resulting in a short inference path and low computational cost, making it suitable for running with millisecond-level latency on CPUs or consumer-grade GPUs. In contrast, Jev AI, as a hosted service, often runs larger language models or multi-stage pipelines behind the scenes, requiring longer computation and scheduling time per call. The difference in architectural positioning—a specialized small model vs a general-purpose large model service—is the structural reason for the more than threefold difference in decision frequency, not merely the network overhead.

Performance Improvement: Score Doubled

The increase in decision frequency is directly reflected in the game score. The video author mentions that with GLiNER, the average score "more than doubled," whereas Jev AI combined with a language model (LM) can also work but shows only a small improvement.

This result is not surprising: faster responses and higher decision frequency allow the AI agent to eliminate enemies and dodge attacks more effectively, thereby achieving higher scores.

Why Are Local Models Better Suited for Game AI?

The core advantage of local models is the elimination of network latency. For game environments with high real-time requirements, a 12-millisecond response time is almost negligible, while API call latency can reach hundreds of milliseconds. In addition, local models do not depend on external services, offering better stability and privacy.

Of course, local models also have their limitations, such as requiring local computing resources and potentially less timely model updates compared to the cloud. But for game AI scenarios that pursue ultimate performance, local deployment is clearly the better solution.

The Doom game environment is often used as a benchmark platform for AI agents because it provides the real-time perception-decision-action loop required for first-person shooting: the agent needs to choose actions such as movement, turning, and shooting based on the screen or game state within a very short time. Such environments have continuous action spaces and fast-changing states, making them extremely sensitive to the decision cycle. Platforms such as ViZDoom in academia are designed precisely for this, allowing researchers to run agents at a fixed frame rate and measure scores. In this setting, the number of decisions an agent can execute per second directly determines the granularity of its response to events such as enemy appearance and trajectory changes, which also explains why an increase in decision frequency translates into a significant improvement in score.

Conclusion

This comparison experiment clearly demonstrates the advantages of local models in latency-sensitive tasks. With a 12-millisecond response time and a decision frequency of 8.8 per second, GLiNER significantly outperforms the Jev AI API in Doom. For game AI developers, if real-time performance is a key requirement, local models are worth prioritizing.

(Note: All data in this article come from the video content, with no additional information added.)