Creating a Fully Functional Computer-Use Agent: Empowering it to Think, Plan, and Execute Virtual Actions Through the Use of Local AI Models

Artificial intelligence has moved beyond the realm of science fiction and into our daily lives. We've seen AI evolve from simple chatbots to sophisticated systems that can generate creative text formats, translate languages, and write different kinds of creative content. Now, we stand at the cusp of a new frontier: autonomous AI agents that can interact with our digital world in a meaningful way. These are not just programs that respond to commands; they are entities that can perceive, reason, and act within a computer environment to achieve specific goals. This guide will walk you through the process of building such an agent, a fully functional computer-use agent, using the power of local AI models.
The ability for an AI to use a computer is a significant leap forward. It transforms the AI from a passive tool into an active partner. Imagine an assistant that can not only draft an email but also open your mail application, find the right recipient, and send it for you. Or consider a research assistant that can browse the web, gather information from multiple sources, and compile it into a summary document, all on its own. These are the kinds of capabilities that computer-use agents bring to the table.
This article will provide a comprehensive tutorial on building your own computer-use agent from the ground up. We will delve into the core concepts, the architectural design, and the step-by-step implementation of each component. By the end, you will have a deep understanding of how to create an AI that can navigate a virtual desktop, interact with applications, and execute tasks to achieve a user-defined objective.

1. Creating a Fully Functional
Computer-Use Agent: Empowering it
to Think, Plan, and Execute Virtual
Actions Through the Use of Local AI
Models

Artificial intelligence has moved beyond the realm of science fiction and into our daily lives.
We've seen AI evolve from simple chatbots to sophisticated systems that can generate
creative text formats, translate languages, and write different kinds of creative content. Now,
we stand at the cusp of a new frontier: autonomous AI agents that can interact with our
digital world in a meaningful way. These are not just programs that respond to commands;
they are entities that can perceive, reason, and act within a computer environment to
achieve specific goals. This guide will walk you through the process of building such an
agent, a fully functional computer-use agent, using the power of local AI models.
The ability for an AI to use a computer is a significant leap forward. It transforms the AI from
a passive tool into an active partner. Imagine an assistant that can not only draft an email but
also open your mail application, find the right recipient, and send it for you. Or consider a
research assistant that can browse the web, gather information from multiple sources, and
compile it into a summary document, all on its own. These are the kinds of capabilities that
computer-use agents bring to the table.

2. This article will provide a comprehensive tutorial on building your own computer-use agent
from the ground up. We will delve into the core concepts, the architectural design, and the
step-by-step implementation of each component. By the end, you will have a deep
understanding of how to create an AI that can navigate a virtual desktop, interact with
applications, and execute tasks to achieve a user-defined objective.
Why the Focus on Local AI Models?
In an era dominated by large, cloud-based AI services, you might wonder why we would
choose to run our models locally. The answer lies in a few key advantages that are
becoming increasingly important:
●​Privacy and Data Security: When you use a cloud-based AI service, you are
sending your data to a third-party server. For sensitive information, this can be a
significant security risk. By running the AI model on your own machine, you maintain
complete control over your data, ensuring that it never leaves your local environment. ●​Cost-Effectiveness: While cloud-based AI services can be powerful, they often
come with a recurring cost. For developers and businesses that require frequent or
high-volume use of AI, these costs can add up quickly. Running a local model
eliminates these subscription fees, making it a more economical solution in the long
run.
●​Offline Capabilities: A local AI model does not require an internet connection to
function. This means that your computer-use agent can operate in environments with
limited or no connectivity, providing a level of reliability that cloud-based solutions
cannot match. ●​Control and Customization: When you use a third-party API, you are limited to the
features and functionalities that the provider offers. With a local model, you have the
freedom to fine-tune its behavior, customize its responses, and integrate it with your
applications in any way you see fit.
Throughout this guide, we will be using open-weight models that are freely available for
anyone to use and modify. This commitment to open-source technology empowers
developers to build upon the work of others and contribute to the advancement of the field.
This tutorial is designed for those with a foundational understanding of Python programming
and a curiosity about the inner workings of AI agents. We will start with the basic building
blocks and gradually assemble them into a cohesive and functional system. By the end of
this journey, you will not only have a working computer-use agent but also the knowledge
and skills to extend its capabilities and adapt it to your own unique needs.
Foundational Concepts and Architecture
Before we dive into the code, it's important to understand the fundamental principles that
govern the behavior of intelligent agents. At its core, an agent operates on a continuous
cycle of perceiving its environment, reasoning about what it perceives, and then taking an
action to influence that environment. This is often referred to as the
perception-reasoning-action loop.

3. The Perception-Reasoning-Action Loop
This loop is the cognitive engine of our agent. Let's break down each stage:
1.​Perception: This is the agent's ability to observe and understand its surroundings. In
the context of a computer-use agent, the "environment" is the digital desktop. The
agent "perceives" this environment by taking a "screenshot" of the current screen
state. This screenshot is not just a visual image; it's a representation of the
information available to the agent, including which applications are open, what text is
visible, and where the current focus of the user is.
2.​Reasoning: Once the agent has perceived its environment, it needs to decide what
to do next. This is where the language model comes in. The agent feeds its
perception of the screen, along with the user's ultimate goal, into the language
model. The model then "reasons" about the current state and the desired outcome to
determine the most logical next step. This might involve clicking on a button, typing
some text, or opening a new application.
3.​Action: The final stage of the loop is to execute the action that the reasoning engine
has decided upon. The agent has a set of "tools" at its disposal, such as the ability to
"click" or "type." It uses these tools to interact with the virtual environment, thereby
changing its state. This new state is then perceived in the next iteration of the loop,
and the cycle continues until the agent has achieved the user's goal.
Key Components of Our Computer-Use Agent
To implement the perception-reasoning-action loop, we will build a system with several key
components, each with a specific role to play:
●​The Environment Layer: This is the simulated world in which our agent lives and
operates. We will create a
VirtualComputer class that represents a miniature
desktop environment. This virtual computer will have its own set of applications, such
as a web browser, a notes app, and an email client. The state of this environment,
including which application is in focus and what is currently displayed on the screen,
will be meticulously tracked.
●​The Perception Module: This module is responsible for allowing the agent to "see"
its environment. In our implementation, this will be a
screenshot function within the
VirtualComputer class. This function will provide a textual description of the
current state of the virtual desktop, which will serve as the agent's perception.
●​The Reasoning Engine: The brain of our operation is the LocalLLM class. This
component will be powered by a local language model, such as Flan-T5. Its job is to
take the agent's perception and the user's goal as input and produce a reasoned
decision about the next action to take. We will carefully craft the prompts we send to
this model to guide its reasoning process and ensure that it makes sensible choices.
●​The Action Execution Layer: This layer provides the agent with the means to
interact with its environment. We will create a
ComputerTool class that acts as an
interface between the reasoning engine and the virtual computer. This class will
define a set of high-level actions that the agent can perform, such as
click and

4. type. When the reasoning engine decides on an action, it will call the corresponding
function in the
ComputerTool class to execute it.
By designing our agent with this modular architecture, we create a system that is both
powerful and extensible. Each component has a clearly defined responsibility, making the
system easier to understand, debug, and expand upon in the future.
Challenges in Building Computer-Use Agents
Creating a truly effective computer-use agent is not without its challenges. The digital world
is a complex and dynamic place, and an agent must be able to handle a wide variety of
situations. Some of the key challenges we will need to address include:
●​Action Space Complexity: The number of possible actions that a user can take on
a computer is vast. An agent must be able to navigate this complex action space and
choose the most appropriate action at any given moment.
●​Error Handling and Recovery: Things don't always go as planned. An agent might
click on the wrong button, or a web page might fail to load. A robust agent must be
able to detect these errors and recover from them gracefully.
●​Context Management: To make intelligent decisions, an agent needs to remember
what it has done in the past and how its actions have affected the environment. This
requires a sophisticated context management system that can track the history of the
interaction and use it to inform future decisions. ●​Token Budget Limitations: Language models have a finite context window,
meaning they can only process a certain amount of text at a time. We will need to be
mindful of this limitation and design our prompts and perception system to provide
the most relevant information within the available token budget.
By understanding these challenges upfront, we can design our agent to be more resilient,
adaptable, and ultimately, more useful.
Setting Up the Development Environment
Before we can start building our agent, we need to prepare our development environment.
This involves installing the necessary libraries and configuring our workspace.
Hardware and Software Requirements
To follow along with this tutorial, you will need a computer with Python 3.6 or higher installed.
While a GPU is not strictly necessary, it will significantly speed up the performance of the
local language model. If you do not have a GPU, the code will still run on your CPU, but it
will be slower. You will also need sufficient RAM to load the language model into memory.
For the smaller models we will be using, 8GB of RAM should be adequate.
Essential Libraries and Dependencies
Our project will rely on a few key Python libraries:

5. ●​Transformers: This library, developed by Hugging Face, provides a vast collection of
pre-trained models and tools for natural language processing. We will use it to
download and run our local language model.
●​Accelerate: This library helps to simplify the process of running PyTorch models on
different hardware configurations, including CPUs, GPUs, and TPUs. It will help us to
optimize the performance of our language model.
●​nest_asyncio: This library is a utility that allows us to run asynchronous code, which
is code that can run in the background without blocking the main program, within a
Jupyter Notebook or other environments that have their own event loop. This will be
useful for creating a responsive and interactive agent.
You can install all of these libraries with a single command using pip, the Python package
installer:
!pip install -q transformers accelerate sentencepiece nest_asyncio
Development Environment Configuration
You can write and run the code for this tutorial in your favorite Python IDE, such as VS Code
or PyCharm. However, for an interactive and exploratory development experience, we
recommend using a Jupyter Notebook or Google Colab. These environments allow you to
run code in individual cells, making it easy to experiment with different components of the
agent and see the results immediately.
Building the Virtual Computer Environment
The foundation of our computer-use agent is the environment in which it operates. We will
create a simulated desktop environment using a Python class called
VirtualComputer.
This class will manage the state of our virtual world and provide the agent with the means to
interact with it.
Designing the Simulated Desktop
Our VirtualComputer class will be a self-contained representation of a simple desktop. It
will have the following key features:
●​An Application Registry: The virtual computer will have a dictionary of applications
that the agent can interact with. In our initial implementation, this will include a web
browser, a notes app, and an email client.
●​State Management: The class will keep track of the current state of the virtual
desktop, including which application is currently in focus and what is being displayed
on the screen.
●​A Screenshot Function: The agent needs a way to perceive its environment. The
screenshot function will provide a textual description of the current screen state,
which will serve as the agent's perception.
●​An Action Log: To help with debugging and understanding the agent's behavior, we
will include a log of all the actions that the agent has taken.

6. Implementing Core Applications
Let's take a closer look at the applications that will be available in our virtual computer:
●​The Browser: The browser will be a simple simulation that can navigate to a URL
and display a page headline. In a real-world scenario, this could be extended to
parse the full HTML of a web page and extract relevant information.
●​The Notes Application: This application will allow the agent to create and edit text
notes. The content of the notes will be stored within the
VirtualComputer class.
●​The Mail Application: The mail application will display a list of email subjects in an
inbox. For simplicity, our implementation will be read-only, but it could be extended to
allow the agent to open and read the full content of emails.
Code Walkthrough: The VirtualComputer Class
Here is the Python code for our VirtualComputer class:
class VirtualComputer:
def __init__(self):
self.apps = {"browser": "https://example.com", "notes": "", "mail": ["Welcome to CUA",
"Invoice #221", "Weekly Report"]}
self.focus = "browser"
self.screen = "Browser open at https://example.com\nSearch bar focused."
self.action_log = []

def screenshot(self):
return f"FOCUS:{self.focus}\nSCREEN:\n{self.screen}\nAPPS:{list(self.apps.keys())}"

def click(self, target:str):
if target in self.apps:
self.focus = target
if target=="browser":
self.screen = f"Browser tab: {self.apps['browser']}\nAddress bar focused."
elif target=="notes":
self.screen = f"Notes App\nCurrent notes:\n{self.apps['notes']}"
elif target=="mail":
inbox = "\n".join(f"- {s}" for s in self.apps['mail'])
self.screen = f"Mail App Inbox:\n{inbox}\n(Read-only preview)"
else:
self.screen += f"\nClicked '{target}'."
self.action_log.append({"type":"click","target":target})

def type(self, text:str):
if self.focus=="browser":
self.apps["browser"] = text
self.screen = f"Browser tab now at {text}\nPage headline: Example Domain"
elif self.focus=="notes":
self.apps["notes"] += ("\n"+text)

7. self.screen = f"Notes App\nCurrent notes:\n{self.apps['notes']}"
else:
self.screen += f"\nTyped '{text}' but no editable field."
self.action_log.append({"type":"type","text":text})
Let's break down the key parts of this code:
●​The __init__ method initializes the virtual computer with our three core
applications and sets the initial focus to the browser.
●​The screenshot method returns a formatted string that describes the current state
of the virtual desktop. This is the information that the agent will use to make its
decisions.
●​The click method simulates a mouse click on a target. If the target is an
application, the focus is switched to that application and the screen is updated
accordingly.
●​The type method simulates typing text into the currently focused application. The
behavior of this method depends on which application is in focus.
This VirtualComputer class provides a simple yet effective simulation of a desktop
environment. It gives our agent a world to explore and interact with, and it lays the
groundwork for the more complex behaviors we will implement later.
Implementing the Local Language Model
With our virtual environment in place, it's time to build the reasoning engine for our agent.
We will use a local language model to power this engine, and we will create a wrapper class
called
LocalLLM to make it easy to interact with the model.
Selecting the Right Model
For this tutorial, we will be using google/flan-t5-small, a member of the Flan-T5 family
of models. Flan-T5 is a powerful and versatile language model that has been fine-tuned on a
massive collection of instructional datasets. This makes it particularly well-suited for tasks
that require following instructions and reasoning about a given context, which is exactly what
our computer-use agent needs to do.
We have chosen the "small" version of the model because it is relatively lightweight and can
run on a wide range of hardware, including machines without a dedicated GPU. However,
the Flan-T5 family also includes larger and more powerful models, such as
flan-t5-base
and
flan-t5-large. If you have the hardware resources, you can easily swap in one of
these larger models for improved performance.
Building the LocalLLM Wrapper

8. To make it easy to work with our chosen language model, we will create a simple wrapper
class called
LocalLLM. This class will handle the details of loading the model, generating
text, and managing the device on which the model is run.
Here is the code for the LocalLLM class:
import torch
from transformers import pipeline

class LocalLLM:
def __init__(self, model_name="google/flan-t5-small", max_new_tokens=128):
self.pipe = pipeline("text2text-generation", model=model_name, device=0 if
torch.cuda.is_available() else -1)
self.max_new_tokens = max_new_tokens

def generate(self, prompt: str) -> str:
out = self.pipe(prompt, max_new_tokens=self.max_new_tokens,
temperature=0.0)[0]["generated_text"]
return out.strip()
Let's examine the key parts of this class:
●​The __init__ method initializes a pipeline from the transformers library. This
pipeline handles all the complexities of loading the model and preparing it for text
generation. We also specify the
device on which the model should be run. If a GPU
is available, it will be used; otherwise, the model will run on the CPU.
●​The generate method takes a prompt as input and returns the generated text. We
set the
temperature to 0.0 to make the model's output more deterministic and less
random.
This simple wrapper class provides a clean and convenient interface for interacting with our
local language model. It abstracts away the low-level details of the
transformers library,
allowing us to focus on the higher-level logic of our agent.
Creating the Tool Interface Layer
Now that we have our virtual environment and our reasoning engine, we need a way to
connect them. This is the job of the tool interface layer. We will create a class called
ComputerTool that will act as a bridge between the agent's reasoning and the execution of
actions in the virtual computer.
The ComputerTool Class Architecture
The ComputerTool class will have a simple but important responsibility: to translate the
commands generated by the language model into actions that can be performed by the

9. VirtualComputer. It will expose a run method that takes a command and its arguments
as input and then calls the appropriate method on the
VirtualComputer instance.
Here is the code for the ComputerTool class:
class ComputerTool:
def __init__(self, computer:VirtualComputer):
self.computer = computer

def run(self, command:str, argument:str=""):
if command=="click":
self.computer.click(argument)
return {"status":"completed","result":f"clicked {argument}"}
if command=="type":
self.computer.type(argument)
return {"status":"completed","result":f"typed {argument}"}
if command=="screenshot":
snap = self.computer.screenshot()
return {"status":"completed","result":snap}
return {"status":"error","result":f"unknown command {command}"}
The run method of this class is a simple dispatcher. It checks the value of the command
parameter and then calls the corresponding method on the
VirtualComputer instance. It
also returns a status dictionary that indicates whether the command was completed
successfully. This feedback mechanism will be important for the agent to understand the
outcome of its actions.
Building the Intelligent Agent Controller
We have now assembled all the building blocks of our computer-use agent. We have a
virtual environment, a reasoning engine, and a tool interface to connect them. The final piece
of the puzzle is the intelligent agent controller, which we will implement in a class called
ComputerAgent. This class will be responsible for managing the agent's decision-making
loop and orchestrating the interactions between all the other components.
The ComputerAgent Class Overview
The ComputerAgent class will be the central hub of our system. It will be responsible for:
●​Managing the Agent's Lifecycle: The agent will operate in a loop, continuously
perceiving, reasoning, and acting until it has achieved its goal. The
ComputerAgent
class will manage this loop and ensure that it runs smoothly.
●​State Tracking: The agent will need to keep track of its own internal state, including
the user's goal and the number of steps it has taken.

10. ●​Budget Management: To prevent the agent from running indefinitely, we will give it a
"trajectory budget," which is the maximum number of steps it can take to achieve its
goal.
The Agent Decision Loop
The heart of the ComputerAgent class will be its run method, which will implement the
perception-reasoning-action loop. Here is a high-level overview of the steps involved in each
iteration of the loop:
1.​Observation: The agent starts by taking a screenshot of the virtual computer to
perceive its current state.
2.​Reasoning: The agent then constructs a prompt that includes the user's goal and the
current screen state. This prompt is fed into the local language model, which
generates a response that contains the agent's next action.
3.​Action: The agent parses the response from the language model to extract the
command and its arguments. It then uses the
ComputerTool to execute the action
in the virtual computer.
4.​Reflection: The agent checks to see if it has achieved its goal. If it has, the loop
terminates. Otherwise, the loop continues to the next iteration.
Code Walkthrough: The ComputerAgent Class
Here is the code for our ComputerAgent class:
import uuid

class ComputerAgent:
def __init__(self, llm:LocalLLM, tool:ComputerTool, max_trajectory_budget:float=5.0):
self.llm = llm
self.tool = tool
self.max_trajectory_budget = max_trajectory_budget

async def run(self, messages):
user_goal = messages[-1]["content"]
steps_remaining = int(self.max_trajectory_budget)
output_events = []

while steps_remaining > 0:
screen = self.tool.computer.screenshot()
prompt = (
"You are a computer-use agent.\n"
f"User goal: {user_goal}\n"
f"Current screen:\n{screen}\n\n"
"Think step-by-step.\n"
"Reply with: ACTION ARG THEN .\n"
)

11. thought = self.llm.generate(prompt)

# ... action parsing and execution logic ...

steps_remaining -= 1

# ... return output events ...
In the full implementation of the run method, we will add the logic for parsing the language
model's response and executing the chosen action. We will also create a system for logging
the events that occur during the agent's execution, which will be useful for debugging and
understanding the agent's behavior.
Asynchronous Execution and Streaming
To create a truly interactive and responsive computer-use agent, we will use asynchronous
programming techniques. This will allow the agent to perform its actions in the background
without blocking the main program, and it will enable us to stream the agent's thoughts and
actions back to the user in real time.
Why Asynchronous Architecture?
An asynchronous architecture offers several key benefits for our computer-use agent:
●​Real-Time Feedback: By running the agent's decision-making loop asynchronously,
we can provide the user with real-time updates on the agent's progress. This creates
a more engaging and transparent user experience.
●​Non-Blocking Operations: Asynchronous operations do not block the execution of
the main program. This means that the user interface can remain responsive while
the agent is busy working on a task.
●​Scalability: An asynchronous architecture can be more scalable than a traditional
synchronous one. It allows the agent to handle multiple tasks concurrently, making it
more efficient and powerful.
Implementing Async/Await Patterns
Python's asyncio library provides a powerful framework for writing asynchronous code. We
will use the
async and await keywords to define and run our asynchronous functions. The
nest_asyncio library will allow us to use asyncio within a Jupyter Notebook or other
environments that have their own event loop.
Our ComputerAgent's run method will be an async function, and we will use a generator
to
yield the output events as they are generated. This will create a stream of events that
can be consumed by the user interface in real time.
Complete Demo Implementation

12. Now it's time to put all the pieces together and run a complete demo of our computer-use
agent. We will create a
main_demo function that initializes all the components, defines a
user goal, and then runs the agent.
Setting Up the Demo
Here is the code for our main_demo function:
import asyncio

async def main_demo():
computer = VirtualComputer()
tool = ComputerTool(computer)
llm = LocalLLM()
agent = ComputerAgent(llm, tool, max_trajectory_budget=4)
messages=[{"role":"user","content":"Open mail, read inbox subjects, and summarize."}]

async for result in agent.run(messages):
print("==== STREAM RESULT ====")
for event in result["output"]:
if event["type"]=="computer_call":
a = event.get("action",{})
print(f"[TOOL CALL] {a.get('type')} -> {a.get('text')} [{event.get('status')}]")
if event["type"]=="computer_call_output":
snap = event["output"]["image_url"]
print("SCREEN AFTER ACTION:\n", snap[:400],"...\n")
if event["type"]=="message":
print("ASSISTANT:", event["content"][0]["text"], "\n")

loop = asyncio.get_event_loop()
loop.run_until_complete(main_demo())
In this demo, we have given the agent the goal of opening the mail application, reading the
subjects of the emails in the inbox, and then providing a summary. We have also set a
max_trajectory_budget of 4, which means the agent has a maximum of four steps to
achieve this goal.
Running the Agent and Analyzing Its Behavior
When we run this demo, we will see a stream of output that shows the agent's thoughts and
actions at each step of the process. The agent will start by taking a screenshot of the initial
screen state. It will then use the language model to reason about its next action. We will see
the agent decide to click on the "mail" application, then take another screenshot to see the
result of its action. This process will continue until the agent has successfully read the email
subjects and provided a summary, or until it has run out of steps. By analyzing the output of this demo, we can gain valuable insights into the agent's
decision-making process. We can see how it interprets the user's goal, how it uses its tools

13. to interact with the environment, and how it adapts its behavior based on the feedback it
receives.
Advanced Features and Enhancements
The computer-use agent we have built in this tutorial is a powerful tool, but it is only the
beginning. There are many ways to extend and enhance its capabilities. Here are a few
ideas for advanced features you could add:
●​Memory and Context Management: You could give the agent a memory to help it
remember its past actions and observations. This would allow it to learn from its
experiences and make more intelligent decisions in the future.
●​Multi-Modal Capabilities: You could add a vision component to the agent, allowing it
to "see" the screen in a more human-like way. This would enable it to interact with
graphical user interfaces and understand the visual layout of applications.
●​Real-World Computer Control: You could transition the agent from a virtual
environment to a real one by integrating it with a library like
PyAutoGUI. This would
allow the agent to control the mouse and keyboard on a real computer, opening up a
whole new world of possibilities.
●​Enhanced Reasoning Capabilities: You could experiment with more advanced
prompting techniques, such as chain-of-thought prompting or the ReAct pattern, to
improve the agent's reasoning abilities.
Conclusion
In this comprehensive guide, we have explored the process of building a fully functional
computer-use agent from the ground up. We have learned about the foundational concepts
of agent architecture, the key components of a computer-use agent, and the step-by-step
implementation of each of these components. We have also seen how to use local AI
models to power the agent's reasoning engine, and we have discussed the benefits of this
approach in terms of privacy, cost-effectiveness, and control. The field of autonomous AI agents is still in its early stages, but it is evolving rapidly. The
techniques and technologies we have discussed in this tutorial provide a solid foundation for
building the next generation of intelligent agents. As language models become more
powerful and accessible, we can expect to see computer-use agents that are even more
capable and sophisticated. These agents have the potential to automate a wide range of
tasks, from personal productivity to business process automation, and to transform the way
we interact with our digital world. The journey of building a computer-use agent is a challenging but rewarding one. It requires
a deep understanding of AI, software engineering, and human-computer interaction. But with
the right tools and techniques, it is a journey that is within the reach of any curious and
determined developer. We hope that this guide has provided you with the knowledge and
inspiration to embark on your own journey into the exciting world of autonomous AI agents.

14. More Posts:
●​GitHub MCP Server Enhanced: Now Offering Support for GitHub
Projects and Additional Features
●​Your AI Education Starts Now: Begin Learning All Facets of Artificial
Intelligence on the Latest Google Skills Offering
●​DeepSeek’s Open-Source Model: Compressing Text 10x Through
Images
●​Launch Your Own Search Engine: A Complete Guide to Self-Hosting
SearXNG
●​Inside China’s AI Accelerator Revolution: A Deep Dive into the
Huawei Atlas 300I Duo Teardown