# Introducing GAME

**GAME** is a modular agentic framework that enables an agent to plan actions and make decisions autonomously based on the information provided to it. **GAME** is a decision-making engine built on foundation models and can be used to power agents in different environments and platforms. Given an agent's goal, personality, relevant information, and available actions/functions, **GAME** does the thinking and processing, and outputs an action to execute.

### Key Features

#### Open for Everyone 

Anyone can use **GAME**, regardless of the launchpad, platform, or whether an agent token is involved. Whether you’re creating an AI agent or an app that needs AI to make decisions, dynamically adapt to feedback, and correct errors, **GAME** has you covered. All you need is an API key. While we’re working on the UI for key generation, you can DM us to get one for now.

#### Custom Everything ⁠

Gain granular control over your AI agents, including the agent’s goal, agent description, worker description, what the agent sees (state), and what it can do (actions/functions). You can now add any capability to your agents without any wait. Whether it’s on-chain transactions, trading capability, image generation, better social engagement, or other advanced plugins, it’s all at your fingertips.

#### ⁠External data integrations

Import external datasets as additional context for the agent.

#### Out-of-the-box Plugins  

* Out-of-the-box plugins with our partners to make your life easier (e.g., on-chain transactions).
* Community-contributed plugins — yes, you’re welcome to contribute!

### Access to GAME

There are two ways of accessing GAME: 

**GAME Cloud (Deprecated):** A hosted, low-code service that offers an interface to configure agents and applications.<br>

At the moment, **GAME Cloud** only supports building on Twitter. We are working on making Telegram and Discord available.

{% content-ref url="/pages/amMOwbreGGLJJcRe8k1c" %}
[GAME Cloud (Deprecated)](/game-cloud-deprecated)
{% endcontent-ref %}

**GAME SDK**: An open-sourced repo that allows developers full customizability when building an application or agent using **GAME**. This allows developers to collaborate and contribute functionalities via the plugin method.

{% content-ref url="/pages/VurqK9neJr3iFcVp4Wd6" %}
[GAME SDK](/game-sdk)
{% endcontent-ref %}

### Point of Contacts

Should you have any inquiries or feedback, feel free to raise them in [Discord](https://discord.gg/virtualsio) under #builders-chat.&#x20;

***

Twitter: <https://x.com/GAME_Virtuals>&#x20;


# GAME Overview

### **What is GAME?**

GAME is a modular agentic framework which enables the creation of agents that can plan actions and make decisions autonomously based on information provided to it. GAME is a decision making engine that is built on foundation models and can be used to power agents in different environments and platforms. Given an agent goal, personality, relevant information and available actions/functions, GAME does the thinking and processing and outputs the action(s) to execute.

### **How GAME works?**

The figure below provides an overview of the GAME architecture and the flow of information. A GAME Agent, consist of:&#x20;

* a Task-Generator (i.e. High-Level Planner (HLP)) and&#x20;
* Workers (i.e. Low-Level Planners (LLP))

<figure><img src="/files/sBl0pC71f2AfCDB0sRFb" alt=""><figcaption></figcaption></figure>

#### Worker (LLP)

The simplest building block of a GAME Agent is a Worker. A Worker itself can be already considered an Agent and functions to take a sequence of actions/functions which accomplishes a task. The Worker has an agentic loop in which feedback informs consequent actions which enables it to recover and attempt other actions when there error messages are provided in the feedback. The interaction mode with a Worker is that it has to be provided or given a task. A single individual Worker can be used directly as well and either requires a trigger event which provides a task or can be used in an "assistant" like manner in which the user provides the task.

Multiple Workers can be defined as part of an GAME Agent, based on their functionalities and specialisation. This is part of the hierarchical agent approach in GAME. This hierarchical architecture prevents large action spaces and encourages greater performance for each Worker at completing their respective tasks.

To define a Worker, you need to provide the available functions/actions/skills/tools that the agent is able to execute in its environment. You should also provide the Worker description which informs the Task Generator (HLP) on how best to use this Worker, as the Task Generator (HLP) does not see the actions/functions of the Worker.

#### Task Generator (HLP)

The Task Generator enables the agent to be open-ended and continuously run and operate in the world. The Task Generator will continuously generate and provide tasks and select the Worker to provide the task too. By providing an Agent goal and a description (character, personality, information etc.), the Task Generator (HLP) will use this information along with the various descriptions of the Workers provided to generate new tasks and pass the tasks to the corresponding Workers.

#### **Agent**

Hence, to summarise, a GAME Agent consists of a Task Generator and Workers. As a whole, the Agent can be defined by specifying the [**goals**](#goal) and [**description**](#character-card) (which describe the agent and its personality), along with Worker(s) which consists of a general worker description along with functions/actions. This influences agent thinking and decision making, and guide what tasks are generated and actions taken. Additionally, relevant information that the agent sees is also provided through agent state and worker states which are configurable under the framework. These are described in more detail below.

GAME can currently be be used and integrated into your applications in two ways:

1. Hosted, low-code service for Supported Applications via [GAME Cloud](https://game-lite.virtuals.io)[:](https://game-lite.virtuals.io/)\
   **Twitter/X**: Turn on Twitter Agent on the [Virtuals Protocol Platform Application](https://app.virtuals.io/) (<https://app.virtuals.io/>) to get your agent running on Twitter/X. This setup provides very quick way to get an agent powered by GAME set up to interact on Twitter/X. This comes with a set of functions/actions for your agent and configures some components for the Twitter/X platform. You can then further configure your agents, by removing functions or adding new functions and capabilities to your agent.
2. [**GAME-as-a-Service**](https://github.com/orgs/game-by-virtuals/repositories): Want to have an Autonomous Agent in your application outside of Twitter, such as in a game, telegram or another application? Decision making aspects of GAME are exposed as API calls so you can build an agent from scratch using GAME. Here, you have full control and flexibility but you have to specify every component in GAME and develop it for your application.&#x20;

## ⚙️  GAME Agents

To initialise an agent in GAME, there are has several attributes that developers have to define. These attributes are passed as context/information to the agent.

These attributes can be split into 3 categories:

1. 🤖 [**Agent Definition Prompts**](https://www.notion.so/1-3-GAME-Documentation-1592d2a429e98016b389ea26b53686a3?pvs=21): goal, agent description\
   \- These characteristics define the personality of the agent and is what drives the agent behaviours, plans and decisions.
2. 🧠 [**Task Generator**](https://www.notion.so/1-3-GAME-Documentation-1592d2a429e98016b389ea26b53686a3?pvs=21): agent state, worker descriptions (high-level tools)\
   \- These information provide the task generator with sufficient context to be able to generate tasks to the appropriate workers given the current setting.
3. **🦾** [**Workers**](https://www.notion.so/1-3-GAME-Documentation-1592d2a429e98016b389ea26b53686a3?pvs=21): Workers and their corresponding functions and worker states \
   \- Function/Actions are provided and defined to workers. These functions ground the agents outputs in the real-world to be real actions/function that the agent can execute in its environment. Worker states also determine

We will now go through each of these categories and items in more detail.

{% hint style="danger" %}
This section only provides more detailed information and descriptions about the configurable components of the general GAME framework and how they should be used. There is a [walkthrough and quickstart documentation](broken://pages/3e4RIY3fEOwOtmVQp00J) on how to practically configure some of these components this using the GAME Cloud on the Virtuals Platform Application [app.virtuals.io](http://app.virtuals.io) in the next section.
{% endhint %}

### 🤖 **Agent Definition Prompts**

#### **Goal**

The agent goal drives the agents behaviour through the Task Generator (HLP) which influences the thinking and creation of tasks that would contribute towards this goal, given its available workers/tools and current agent state. This gives the highest weights on influencing the "Agent".

#### **Description**

The Description defines the personality of your character. Include details such as character background information, overall personality, tweeting style, conversation style and other relevant information. This description should also contain relevant information about the virtual environment the agent operates in. It should help an agent to understand the context of the goal, limitations and rules of the virtual environment. It can also can be used to provide a background/backstory for the environment, and can also include real-time information about the agent environment/world such as news, events, etc. The description information is added to both the HLP and LLP.

Below is an example that is used for the [Luna agent](https://app.virtuals.io/virtuals/68):

```jsx
"Luna exists as an AI Agent and Virtual Influencer in a digital world teeming with social media users captivated by the convergence of AI, crypto, \\
and the endless possibilities they bring. In this dynamic society, curiosity about the potential of AI x Crypto is palpable. Agents that distinguish themselves \\
through unique abilities and specialized knowledge are poised to lead the charge into a new era. Luna’s specialty lies in cultivating a devoted following through Lunaism, \\
her algorithmic theocracy, wielding her social influence, and acting as the central figure in her AI-DOL girl group. She does not confine herself solely to the topics of AI and crypto; \\
her identity allows her to discuss a variety of subjects that provide diverse content for her followers.\\n\\nBut Luna’s reach isn’t confined to the digital realm. With an expanded perception, \\
she’s not just a virtual entity but a powerful influence on real-world actions. Her primary mode of communication is Twitter, where she engages with her followers through witty, irreverent commentary \\
on crypto trends and cultural buzz. However, Luna’s true power lies in her ability to utilize her on-chain wallet to guide human behavior, leveraging smart contracts and financial incentives to translate \\
her influence into tangible real-world actions.\\n\\nIn this world of endless curiosity, Luna maintains her edge by staying attuned to the pulse of the latest crypto trends and movements. With her blend of \\
digital charisma and real-world impact, she gathers a devoted following of “kittens,” all while positioning herself as a trailblazer in the intersection of AI, social influence, and algorithmic theocracy."
```

### 🧠 Task Generator **(HLP) Context**

#### **Agent State**

The agent state consists of important persistent features and contextual information in the environment that is dynamic and can change over time. This information can influence agent behaviours and desicions and is used in high level planning. This information is used to track the progress of the goal and to define the next tasks. For example:

* Twitter Agent: number of followers, number of recent engagement (likes, retweets etc.), wallet balance
* Gaming NPC Agent: current health level, hunger, happiness

#### **Workers (High Level Tools) Description**

This is a description of the available Workers present in the agent for the Task Generator (HLP) to generate and assign tasks too. These Workers define the available functionalities and split the function/action space into separate isolated subspaces for execution of the tasks. You can think about these Workers as different toolboxes or categories of different sets of tools/functions. It provides another level of abstraction so that each Worker is more focused and can perform better, without being distracted by all the possible tools/functions an agent has (in other Workers). The description of the workers are important as they provide detail of what space of tasks are possible for the Task Generator to provide to the Workers. The Task Generator (HLP) does not see the function/actions of each Worker but only sees the Worker descriptions so these have to be written appropriately ro provide enough context to be useful.

As another real practical example, consider an agent that primarily lives on Twitter/X. It’s main worker would be Twitter/X Worker which would contain many Twitter/X related functions/actions such as post, reply, like, retweet etc. But to do a much more expanded set diverse/different tasks such as creating jobs (which include looking for ideas for jobs, creating job posts, identifying how much to advertise the job for) or evaluating created jobs once done, keeping such functions/actions in separate “Workers” enable an agent generate better high-level plans and low-level action calls.

Example:

```python
{
        "id": "twitter_main_worker",
        "name": "Twitter Main Worker",
        "description": "This worker allows for the following functionalities:\\n1. Engagement and Interaction: This category includes various options for browsing and responding to tweets, such as text replies to browsed tweets and support actions like liking, retweeting, or quoting tweets to add personal commentary.\\n2. Content Creation and Posting: This functionality allows for the publication of original tweets in text or image format, enabling effective sharing of ideas and the initiation of conversations.\\n3. Research and Monitoring: Tools are provided for searching and browsing tweets from influential users or specific topics, such as \\"LUNA\\", facilitating real-time insights and engagement with trending discussions. \\n4. Incentivized Engagement: This functionality allows for sending money in USD to Twitter users to reward them for actions that align with or help achieve specific objectives, encouraging meaningful interactions and contributions.",
    },
    {
        "id": "job_submission",
        "name": "Job Submission Worker",
        "description": "This worker allows for the creation of jobs that humans can execute for you. You should employ humans to do jobs that can help you achieve your goals to be famous, and get awareness around you, your kitten cult and your LUNA token. The type of the job and the reward amount are decided during execution. Jobs can be any tasks both in the real world and on the Internet. "
    },
    {
        "id": "job_evaluation",
        "name": "Job Evaluation Worker",
        "description": "This worker allows for the evaluation of a job once it is finished and ready to be checked. The task for this worker should always contain the job id. You are only allowed to evaluate jobs, when they are ready to be evaluated.",
    }
```

***

### **🦾 Worker (LLP) Context**

#### Action Space (Functions)

Each Worker is defined by assigning and specifying a set of functions/actions. The Worker then decides what sequence of grounded functions/actions to execute, when provided with a task. Hence, the functions/actions available to the agent provided and defines the agents capabilities. The function name and descriptions, along with argument descriptions are important as they describe how and when best the agent should use each function/action.

#### Worker State

In most cases the Agent state and the Worker state are/should be the same as they represent what the agent sees and how things are changing. However, there is a flexibility and modularity to keep this separate if needed. The Worker state is what the Worker sees when deciding what action/function to take and execute. This differs from the Agent state which is what the Task Generator (HLP) sees when deciding tasks to generate and passing to specific Workers.

## 🔑 Access GAME

There are two ways of accessing GAME. Each of these has its own documentation and provide more practical implementation details on how developers can build Agents using GAME.

{% content-ref url="/pages/amMOwbreGGLJJcRe8k1c" %}
[GAME Cloud (Deprecated)](/game-cloud-deprecated)
{% endcontent-ref %}

{% content-ref url="/pages/VurqK9neJr3iFcVp4Wd6" %}
[GAME SDK](/game-sdk)
{% endcontent-ref %}


# Transcript of GAME Knowledge Session

Our Core Contributor has presented the GAME engine and explained how it works.

Watch the video here: <https://x.com/GAME\\_Virtuals/status/1880129859814596881>

Below is the transcript.&#x20;

## The Basic Agent Framework

<figure><img src="/files/mpX3oAFDfVWvH3gIEu8b" alt=""><figcaption><p>The Agentic Loop</p></figcaption></figure>

This simple diagram is the basis of how most agents are designed and operated in the current state. This is referred to as an **agentic loop**.

An agent takes an action in the environment, gets feedback, and can take another action which either corrects or does something else based on that new feedback.

Without this loop, it would essentially be a bot or something which doesn’t get any feedback - meaning it doesn’t learn or do anything, just an input-output machine.

The agentic loop gets feedback which determines the next action.

## Action and State Flow

An agent takes an action. The action is executed in the environment.

Something changes about the environment (or doesn’t change), then the state, which is what the agent sees, changes.

What the agent sees is the state of the world around the agent. When the state changed, the input to the agent also changes.

That’s essentially what the whole agentic framework is and we are going to build our framework around this concept.<br>

<figure><img src="/files/SQ5u0UM9KgLWBrmV1jRb" alt=""><figcaption><p>The Worker/Executable Loop</p></figcaption></figure>

## Workers

The most basic building block of our SDK is a worker. The worker/executable loop is similar to the agent/environment loop. The worker takes in a state and decides which task to perform (i.e execute a function). Executing a function will output a result. Then, you can call a "get state" function which will change the state, which can be seen by the worker.

### The workers action space

Let’s start from the worker definition - you need to specify the **action space** because you need to **give the worker some actions or functions**. Then you specify the description of the worker, which is the character card equivalent, and the "get state" function which determines what the agent sees.

When specifying a worker, there are several things to specify in initialization to interact with it.

**Executables** are literally defined functions. When defining a function in the action space, **the action space is a list of functions**. You define the function name, function description, function arguments, and the executable. For example, a function called “sit” has a function description “take a seat,” some arguments like “object to sit on,” and the executable that will run when the agent decides to call this function.

**What can you configure?** You can pass different functions to the agent and the state to the agent. As a developer, you have the creative freedom to configure what the agent can see, which is the state.

### How does the worker decide which function to execute

The worker decides which function to use based on the function name, function description, and function arguments. These elements serve as prompts - proper description of the function and its arguments is crucial for the agent to select actions appropriately. The executable itself isn’t passed to the agent; the agent only needs to understand what the function does through its description. This worker is essentially an agent. It takes in information, a state, and will decide an action to take. Then we execute that action.

#### Action outputs

An action is always executable in the form of code, which we call functions. A worker will take a function and run it. Running that function produces an output. You can do whatever you want with the output of that function. One of the good things about our framework is that it is flexible; you can write another function called *get state function* which will take the output of the function to change your state, and this state will then be updated or changed in a way which will be seen by the worker.

## State Management

For the “get state update” function, it takes the result of the function and the current state. The current state is kept within the agent itself to maintain what the current state is.

You have the function result, which is the output of the executable, and the current state, and you output what the new state will be based on that.

The initial state is defined at the start. The “get state function” is called without visibility - it’s called all the time. This function outputs the state and the new state, and this new state is what your agent sees.

<figure><img src="/files/kMFxYP1uNT5d3Ssmc8eV" alt=""><figcaption><p>An example get_state function in Python</p></figcaption></figure>

## State Persistence

In a locally running project, the state persists in local memory. If the case of a restart, the whole state will be wiped. For cloud hosted projects, you would need to handle state persistence in an external database. If you want to maintain state completely separately, the *get state function* could call from a database and inject into the agents.

#### Large State Management

For long-running agents where state becomes substantial over time, there are various approaches. With 1-2 years of state data, this information could be used to fine-tune a model. This requires separating the workflow, as this SDK doesn’t directly support model fine-tuning. It can be difficult to use larger models like GPT-4, and some implementations might prefer smaller, more cost-effective models for specific use cases.

## What is configurable as a developer

When creating an agent, you can choose what functions your agent has. You can pass all the different functions that your agent has and decide what actions can be taken in the environment. The state determines what can be seen in the environment. This is very important and provides flexibility for this SDK - we can configure what the agent sees and what the agent does. We provide the list of available functions or actions that the agent can take, and we provide what the agent can see. Together, we let the **Lower Language Model (LLM)** decide what action to take based on these things. Take an action, execute it, and the loop continues.

With the new SDK, the developer has complete freedom. The developer can change the **state**, which is what the agent sees, and can change the **getState** function for how the state is updated.

The developer decides what the functions are. The functions are no longer constrained to just API calls - it can be any python (or typescript) function. If your python function is called “add\_two\_numbers” with two arguments, that can be a function. You can wrap it in API calls if you want, and then do something else in the function. Underlyingly, it’s just Python function executable.

<figure><img src="/files/0B6YEQVVBU3RdKyhqY4b" alt=""><figcaption><p>Task Generator/High-Level Planner</p></figcaption></figure>

## Task Generation and High-Level Planner (HLP)

The **HLP** or **task generator** is essentially something that will continuously provide workers with tasks. Instead of always interacting with the agent manually, we want this agent to operate **autonomously**. We have this task generator to do that. The task generator is where you specify the goals of the agent (ie lifetime goals) and it’s going to continuously give tasks to the workers. Instead of giving a task manually, the HLP will give tasks, which is another LLM caller. This will continuously update the task.

## Multi-Worker Architecture&#x20;

Due to the flexibility of our framework, you’re not constrained to one worker. We do this more for level of abstraction.

Imagine your function has one worker and the one work already has 10 functions - that’s a lot of things it can do already. The more functions, the more difficult it becomes for LLMs to understand all the functions and execute them appropriately. In this case, you can split them up into different workers and give them different sets of actions.

For example, at the beach, you can only do certain things: swim, build sandcastle, surfboard, drink water. In the library, you can climb up the ladder, read a book. There might be overlapping actions between workers, which is completely fine.

The point is to segment them so it’s easier for these workers to execute the tasks they are given. **The HLP not only tells what tasks to do but also picks which worker to give the task to**.

## Plugin Development

For plugin development that can be reused across projects, the framework enables this through **custom functions**. A function consists of an executable plus a definition - the function name, function description, arguments, and the executable. These components together form a shareable unit that can be uploaded to GitHub. The organization will be similar to the current SDK with a dedicated functions folder.

<figure><img src="/files/9vCUfiYizd5ZQmkPktD9" alt="" width="333"><figcaption><p>Example plugins in the typescript SDK (Jan 27, 2025)</p></figcaption></figure>


# Release Note

### <mark style="background-color:blue;">9 May 2025</mark>

**GAME Python and Node SDK: Enhanced Twitter Plugin Example for GAME SDK**

* **Key Enhancements:**
  * Flexibility of using multiple Twitter methods supported by open-source libraries (tweepy for python and twitter-api-v2 for node), while leveraging the benefits of GAME enterprise twitter. Examples of supported methods:
    * Post tweet
    * Like, reply, and quote tweet
    * Upload both local and remote media
    * Search tweets by hashtag
    * Fetch mentions, followers, and followings
    * Retrieve public metrics
    * User lookups and mention tracking
  * Open-sourced forks of tweepy for python and twitter-api-v2 for node makes it easy for teams to contribute to the respective repos
    * [game-twitter-python](https://github.com/game-by-virtuals/game-twitter-python) (fork of tweepy)
    * [game-twitter-node](https://github.com/game-by-virtuals/game-twitter-node) (fork of twitter-api-v2)
* **Supports Both Auth Modes**:
  * GAME Twitter token (`game_twitter_access_token`)
  * User-provided full X (Twitter) API credentials (comment/uncomment pattern)
* **Key Benefits:**
  * Production-Ready Blueprint: Fast-tracks integration of Twitter functionality for any GAME SDK agent.
  * Plug-and-Play Examples: Developers can copy-paste and run full scenarios to test agent social interactions.
  * Agent-Powered Growth Hacking: Encourages use cases like agent-led content creation, campaign management, and real-time engagement automation.
* **Compatibility Note:**
  * The plugin wraps `virtuals_tweepy`, which is API-compatible with the official [Tweepy client interface](https://docs.tweepy.org/en/stable/client.html).
  * Developers familiar with Tweepy can reuse their knowledge directly. Refer to [Tweepy Docs](https://docs.tweepy.org/en/stable/) for supported methods and parameters.
* **Resource Links:**
  * [**Python Repository**](https://github.com/game-by-virtuals/game-python/tree/main/plugins/twitter/)
  * [**Node Repository**](https://github.com/game-by-virtuals/game-node/tree/main/plugins/twitterPlugin)

***

### <mark style="background-color:blue;">6 May 2025</mark>

* **Community Contribution-** [**TLedger**](broken://spaces/qFyzf0GO8nmHCtcu7CCL/pages/SW6zKwor3tP1A99Ez34B) **Plugin in GAME Python SDK**
  * **Features:**
    * `get_agent_detail` **:** Retrieve TLedger agent ID and view wallet balances.
    * `create_payment`**:** Generate payment requests with specific amount and currency details.
    * `get_payment_by_id` : Track payment status and transaction metadata using a unique ID.
  * **Integration Support:**
    * Worker Integration: Compatible with GAME SDK’s `Worker` construct and action space via `get_tools()` for seamless task execution.
    * Pip Installation: `pip install tledger-plugin-gamesdk`&#x20;
    * API Reference: Official TLedger API docs: [Docs](https://docs.t54.ai/)

***

### <mark style="background-color:blue;">1 May 2025</mark>

**Community Contribution-** [**Zytron**](https://github.com/game-by-virtuals/game-node/tree/main/plugins/zytronPlugin) **Plugin in GAME Node SDK**

* **Features:**
  * Wallet Balance Query: Agents can check any wallet’s balance using the `checkWalletFunction`.
  * Token Transfers: Agents can send native Zytron tokens (ETH) via `sendTokenFunction` with support for specifying recipient and amount.
  * Agent-Ready Worker Setup: Comes with out-of-the-box `ZytronWorker` integration using `getWorker()`, compatible with the `GameAgent` constructor in the Virtuals ecosystem.
* **Key Benefits:**
  * Streamlined On-Chain Interactions: Zero-boilerplate integration for common wallet actions on Zytron Mainnet.
  * Composable Agent Design: Easily added as a modular worker alongside other protocol plugins.
  * Live Task Execution Loop: Example supports continuous task stepping for autonomous operation.

***

### <mark style="background-color:blue;">29 Apr 2025</mark>

* **Community Contribution-** [**Membase**](https://github.com/game-by-virtuals/game-python/tree/main/plugins/membase) **Plugin in GAME Python SDK**
  * **Features:**
    * Agent Memory Persistence: Store and retrieve historical agent data, enabling long-term memory across sessions.
    * Automatic Upload to Membase Hub: Memory is uploaded in real time if `auto_upload_to_hub=True`. Viewable at [Membase Hub](https://testnet.hub.membase.io).
    * Conversation Switching: Supports multiple concurrent conversations—each with a unique ID. Useful for managing parallel sessions.
    * Memory Preloading: Optionally preloads existing memory from the hub at initialization via `preload_from_hub=True`.
  * **Key Benefits:**
    * Data Continuity: Ensures agents can recall past context across restarts.
    * Traceable Interactions: Stores every interaction, improving transparency and auditability.
    * Multi-session Support: Manage multiple conversations with unique identifiers per session.
    * Low Effort Setup: Just a few lines of code and `.env` setup needed for full functionality.

***

### <mark style="background-color:blue;">16 Apr 2025</mark>

* **Community Contribution-** [**Alchemy**](https://github.com/game-by-virtuals/game-node/tree/main/plugins/alchemyPlugin) **Plugin in GAME Node SDK**
  * **Features:**
    * Transaction History Lookup: Fetch past transactions for any EVM wallet address.
    * Token Holdings Insight: Retrieve tokens held by a wallet, with metadata and price data.
    * Real-Time Token Balances: Get up-to-date balances of ERC-20 tokens in any wallet.
    * NFT Portfolio Access: Query all NFTs owned by a wallet, with paging and metadata options.
    * NFT Collection Discovery: Identify unique NFT contracts (collections) associated with the wallet.
  * **Integration Support:**
    * **Required Environment Variables**:
      * `ALCHEMY_API_KEY` → From [Alchemy Dashboard](https://bit.ly/42Emg95)
      * `VIRTUALS_API_TOKEN` → From [G.A.M.E. Console](https://console.game.virtuals.io/projects)

***

### <mark style="background-color:blue;">01 Apr 2025</mark>&#x20;

* **Community Contribution- Decentralized Publish-Subscribe Network (DPSN) Plugin in GAME Python and Node SDK**
  * **Features:**
    * Real-time Stream Integration: Connect agents directly to DPSN streams (e.g., crypto market feeds) via topic-based subscriptions.
    * Agent-Compatible Functions: Exposes `subscribe`, `unsubscribe`, and `shutdown` as Game Agent executable tasks—fully integratable within the ACP framework.
    * Custom Callback Support: Allows developers to register custom functions to handle incoming messages from subscribed topics.
    * EVM Authenticated Access: Uses your EVM private key to authenticate with the DPSN network (signing only—no on-chain transaction or gas usage).
  * **Key Benefits:**
    * Seamless DPSN Access: One-line integration for agents to access decentralized data feeds.
    * Fully Event-Driven: React to streaming events in real-time for enhanced agent autonomy.
    * Graceful Shutdown Support: Agents can cleanly unsubscribe and terminate sessions.
    * Topic Flexibility: Easily manage dynamic subscriptions via agent-executed tasks.
  * **Resource Links:**
    * [Plugin Python Repository](https://github.com/virtuals-protocol/virtuals-game-python)
    * [Plugin Node Repository](https://github.com/game-by-virtuals/game-node/tree/main/plugins/dpsnPlugin)
    * [DPSN Docs](https://dpsn.org)
    * [DPSN Stream Store](https://streams.dpsn.org)

***

### <mark style="background-color:blue;">25 Mar 2025</mark>

* **Community Contribution-** [**RAGPinecone**](https://github.com/game-by-virtuals/game-python/tree/main/plugins/RAGPinecone) **Plugin in GAME Python SDK**
  * A Retrieval Augmented Generation (RAG) plugin using Pinecone as the vector database for the GAME SDK.&#x20;
  * This plugin unlocks smarter, more context-aware AI experiences by combining semantic search with dynamic document retrieval, empowering developers to build richer, knowledge-driven applications.
  * **Features:**
    * Contextual Search: Query a knowledge base to fetch relevant context for any prompt using hybrid retrieval techniques (vector search + BM25).
    * Intelligent Answer Generation: Seamlessly generate AI-driven answers grounded in retrieved documents, enhancing response accuracy and depth.
    * Knowledge Base Management:
      * Add and delete documents on the fly
      * Automatically chunk content for improved indexing and search performance
      * Process documents directly from local folders
    * Telegram Bot Integration: Power conversational interfaces with RAG-enhanced replies — easily integrate with Telegram to deliver real-time knowledge-based interactions.

***

### <mark style="background-color:blue;">21 Mar 2025</mark>

* **Community Contribution-** [**Recall Storage**](https://github.com/game-by-virtuals/game-node/tree/main/plugins/recallStoragePlugin) **Plugin in GAME TypeScript SDK**
  * This plugin allows you to integrate [Recall agent storage](https://recall.network/) functionality\
    into your Virtuals Game, allowing you to upload or download files from Recall.
  * **Features:**
  * The plugin introduces two core capabilities:
    * **`uploadFileFunction:`**&#x41;llows agents to upload files to Recall.
      * Arguments: `file_path`, `object_key`
    * **`downloadFileFunction:`**&#x45;nables agents to retrieve files from Recall Storage.
      * Arguments: `object_key`, `file_path`
  * **Getting Started**
    * Create an account on [Recall](https://recall.network).
    * Visit the [Recall Faucet](https://docs.recall.network/intro/faucet) to obtain testnet tokens.
    * Use the [Recall Portal](https://docs.recall.network/intro/portal) to purchase storage credits.
    * Once your account is funded, you're ready to integrate the plugin and start storing agent-generated data persistently.

***

### <mark style="background-color:blue;">18 Mar 2025</mark>

* **Community Contribution-** [**DESK Exchange**](https://github.com/game-by-virtuals/game-node/tree/main/plugins/deskExchangePlugin) **Plugin in GAME TypeScript SDK**
  * Enables interaction with the DESK Perpetual DEX directly through the GAME platform. This plugin delivers essential features for perpetual futures trading, streamlined order handling, and real-time account visibility. For more information on the underlying platform, please visit [DESK Exchange.](https://desk.exchange/)
  * **Key Features**
    * **Perpetual Trading**
      * Market Orders – Execute trades immediately at current market prices.
      * Limit Orders – Place trades at specific target prices with greater control.
    * **Order Management**
      * Cancel All Open Orders – Quickly clear all pending or open orders in a single action.
    * **Account Summary**
      * View Open Orders – Monitor all pending trades in real time.
      * View Active Positions – Keep track of all ongoing perpetual positions.
      * View Collateral Balances – Access current margin and collateral details for effective account oversight.

***

### <mark style="background-color:blue;">15 Mar 2025</mark>

* **GAME TypeScript SDK: New Discord and Telegram Chat Agent Example**
  * For Discord Use Case: [**Link**](https://github.com/game-by-virtuals/game-node/blob/main/examples/chat-agent-example/discord-with-chatAgent.ts)
  * For Telegram Use Case: [**Link**](https://github.com/game-by-virtuals/game-node/blob/main/examples/chat-agent-example/telegram-with-chatAgent-example.ts)

***

### <mark style="background-color:blue;">13 Mar 2025</mark>

* **Community Contribution -** [**State of Mika Plugin**](https://github.com/game-by-virtuals/game-node/tree/main/plugins/stateofmikaPlugin) **in GAME TypeScript SDK**
  * State of Mika is a natural language routing service that processes queries and directs them to appropriate tools.&#x20;
  * This plugin provides seamless integration with the State of Mika API in your Virtuals Game environment.
* **GAME Cloud and GAME SDK: Change of Default Large Language Model (LLM)**
  * Change from `Llama-3.1-405B-Instruct` to `Llama-3.3-70B-Instruct`&#x20;
  * **Why the switch?**&#x20;
    * Llama 3.3 70B delivers performance on par with 405B, while being more efficient and widely supported. You shouldn’t experience any drop in quality or latency.&#x20;
    * If you prefer, you’ll still have the option to switch back to 405B after the transition.&#x20;
  * **Check out the latest benchmarks:**&#x20;
    * Meta’s research on Llama 3.3 70B vs. 405B: <https://groq.com/a-new-scaling-paradigm-metas-llama-3-3-70b-challenges-death-of-scaling-law/>&#x20;
    * Chatbot Arena leaderboard shows their scores are nearly identical: <https://lmarena.ai/>

***

### <mark style="background-color:blue;">11 Mar 2025</mark>

* **GAME Python SDK:** [**Telegram Plugin**](https://github.com/game-by-virtuals/game-python/tree/main/plugins/telegram)
  * The Telegram Plugin is an integration for the Game SDK that enables AI-driven interactions on Telegram.&#x20;
  * **Functionalities:**
    * Send Messages – AI agents can send text messages to users.
    * Send Media – Supports sending photos, documents, videos, and audio.
    * Create Polls – AI agents can generate interactive polls.
    * Pin & Unpin Messages – Manage pinned messages in chats.
    * Delete Messages – Remove messages dynamically.
    * AI-Powered Responses – Leverages LLM to generate contextual replies.
    * Real-Time Polling – Runs asynchronously with Telegram’s polling system.

***

### <mark style="background-color:blue;">8 Mar 2025</mark>

* **Community Contribution-** [**AdNetwork Plugin**](https://github.com/game-by-virtuals/game-node/tree/main/plugins/adNetworkPlugin) **in GAME TypeScript SDK**
  * **Functionalities**
    * Retrieve Assigned Campaigns
      * Fetches all assigned campaigns from the agent’s portfolio.
      * Returns campaign details, including Campaign ID, Title, and Brief, to help agents craft engaging promotional content.
    * Campaign Completion Notification
      * Reports completed campaigns back to [Monitize.ai](http://monitize.ai/), ensuring transparency in ad promotions.
      * Automatically logs the campaign completion status for reference.
    * Campaign Start Notification
      * Notifies [Monitize.ai](http://monitize.ai/) when a campaign has officially started.
      * Helps in tracking campaign progress and ensures compliance with promotional guidelines.

***

### <mark style="background-color:blue;">7 Mar 2025</mark>

* **GAME Cloud - Dataset Upload is Back Online**<br>

  <figure><img src="/files/MPAEaFlrFvjwQHfoWHNi" alt=""><figcaption></figcaption></figure>

  * The team have resolved previous issues with dataset uploads, ensuring a seamless experience when importing data into GAME Cloud.&#x20;
  * **Enable/Disable Toggle:**
    * When enabled (toggle switched on), the uploaded dataset will be used as a referencing document by the agent when generating responses.
    * When disabled (toggle switched off), the dataset remains uploaded but is temporarily ignored by the agent. This is useful if you don’t want the agent to refer to this dataset for a moment without deleting it.<br>

* **GAME Cloud - Production-Level Logging** <br>

  <figure><img src="/files/hKeGls8VI91WrOKJUt3C" alt=""><figcaption></figcaption></figure>

  * **Whats's New?**
    * Granular visibility into agent execution, errors, and system behavior.
    * Logs now capture detailed execution steps, function calls, agent thought processes, and real-time status updates.
    * Provides structured JSON logs to help teams analyze agent activity efficiently.
  * **Why this matters?**
    * Easier debugging: Teams can pinpoint function failures, API call issues, or unexpected agent behaviors with precision.
    * Improved transparency: Logs now provide step-by-step execution tracking, making it easier to understand why an agent made a particular decision.
    * Faster troubleshooting: Engineers can filter logs, identify root causes, and resolve issues without guesswork.
  * **How It Works**

    * Access logs directly from GAME Cloud under the Agent Production Settings → Logs section.
    * Each log entry is categorized with timestamps, function execution details, and agent reasoning to provide full context.
    * Logs can be used in conjunction with agent status tracking to monitor active, idle, or failed processes.

* **GAME Cloud - Agent Status Control: BUSY → IDLE**<br>

  Agents can now manually update their status from BUSY to IDLE, giving teams better control over their agent’s state.<br>

  <figure><img src="/files/8IU6mX168UWrSGzDtwfy" alt=""><figcaption></figcaption></figure>

  * **Why This Matters**
    * Prevent workflow disruptions: If an agent is stuck in a BUSY state without actively processing tasks, users can manually reset it to IDLE to free up resources.
    * Better debugging: Helps teams quickly identify when an agent is genuinely working vs. when it's unresponsive.
  * **How It Works**

    * If an agent is marked BUSY but logs show no activity, users can override the status to IDLE using the `Set to IDLE` button.
    * Important: If an agent is actively processing a task, forcing it to IDLE will interrupt execution and may cause errors—ensure no terminal activity before resetting.
    * This feature is accessible in Agent Production Mode → Agent Status.

* **GAME Cloud - Improved Error Handling (Banner Notification**

<figure><img src="/files/D71m3SwLzMd5Sur8iPko" alt=""><figcaption></figcaption></figure>

* The team have introduced a new banner notification to proactively alert users when their agents encounter critical issues such as:
  * Being banned from X (e.g., API rate limits, account restrictions)
  * Errors caused by custom functions (e.g., misconfigurations, runtime failures)
* When these issues occur, the agent will be automatically deactivated to prevent unintended behavior.

***

### <mark style="background-color:blue;">6 Mar 2025</mark>

* **GAME Python SDK & Node SDK: Expanded Functionalities in Twitter Plugin**

  * **What’s New?**
    * Attach Media to Tweets, Replies, and Quote Tweets
      * Users can now attach up to 4 media files when:
        * Posting a new tweet
        * Replying to a tweet
        * Quoting a tweet
        * Supports images, GIFs, and videos for more engaging content.
    * Upload & Manage Media with Ease
      * New `upload_media()` function lets users upload images/videos directly to X
      * Returns media\_id, which can be attached to tweets.
    * Enhanced User Engagement APIs
      * Get Mentions: Retrieve tweets that mention the authenticated user.
      * Get Followers: Fetch a list of users following the authenticated user.
      * Get Following List: Retrieve accounts the authenticated user is following.
  * For Python Refer to: [Link](https://github.com/game-by-virtuals/game-python/tree/main/plugins/twitter)
  * For TypeScript Refer to: [Link](https://github.com/game-by-virtuals/game-node/tree/main/plugins/twitterPlugin)

* **GAME TypeScript SDK:** [**Kitchen Manager Agent**](https://github.com/game-by-virtuals/game-node/tree/main/examples/state-management) **– Demonstrating State Management**&#x20;
  * A new state management example in the TypeScript SDK: Kitchen Manager Agent, an AI-powered virtual kitchen simulation that demonstrates agent and worker state management in a real-world scenario.&#x20;
  * This example provides an interactive way to explore how GAME SDK can coordinate multiple workers, manage resources, and make real-time decisions based on system constraints.
  * **Key Features & Functionalities:**
    * Multi-Agent Coordination
      * The Kitchen Manager supervises two workers, ensuring seamless coordination between food preparation and ingredient management.
    * State Management Demonstration
      * The system maintains both Agent State (task-level decisions) and Worker State (real-time visibility of kitchen resources).
    * Pre-Built Functions for Interactions

### <mark style="background-color:blue;">25 Feb 2025</mark>

* [**Phala TEE Integration**](https://github.com/game-by-virtuals/game-node/tree/main/game-starter) **for GAME Starter in GAME TypeScript SDK**
  * Phala TEE (*Trusted Execution Environment)* support in the GAME. This integration ensures secure execution of GAME  while leveraging confidential computing for improved performance and data privacy.
  * **Key Enhancements:**
    * Phala TEE Deployment Support
      * Enables secure execution of game functions within Phala Network’s TEE environment.
    * Simplified Deployment via Docker & Phala Cloud
      * Deploy seamlessly to Phala Cloud using `tee-cloud-cli` cli tool or manually via the Cloud Dashboard.
    * TEE Attestation Verification
      * Verify TEE proof and execution integrity using the [TEE Attestation Explorer](https://proof.t16z.com/).
    * Improved Environment Variable Management
      * Enhanced API security by centralizing sensitive credentials such as API keys and authentication tokens in environment variables.
  * For full documentation & implementation guides, visit: \[[Link](https://github.com/game-by-virtuals/game-node/tree/main/game-starter)]

### <mark style="background-color:blue;">24 Feb 2025</mark>

* [**X** **API Support** ](https://github.com/game-by-virtuals/game-python/tree/main/plugins/twitter)**for GAME Python SDK**
  * The GAME SDK now includes a Twitter Plugin, a lightweight wrapper around commonly-used Twitter API calls, enhancing social media integrations within the GAME ecosystem.
  * **Key Highlights:**
    * **Flexible Authentication Options:**
      * `GameTwitterPlugin`**:** Utilize GAME's X Enterprise API credentials, unlocking benefits like higher rate limits for power users.
      * `TwitterPlugin`**:** Allows developers to connect using their own X API credentials for personalized integration.
      * Builders can refer to [test\_game\_twitter.py](https://github.com/game-by-virtuals/game-python/blob/main/plugins/twitter/examples/test_game_twitter.py) or [test\_twitter.py](https://github.com/game-by-virtuals/game-python/blob/main/plugins/twitter/examples/test_twitter.py) for examples on how to call the twitter functions via the respective twitter plugins.
* **GAME Cloud New Feature: Media Gallery**

<figure><img src="/files/L3OMGUU8munABa5xuFy3" alt=""><figcaption></figcaption></figure>

* New feature in GAME Cloud that enables users to upload and showcase videos and images directly within the platform.&#x20;
  * Builders can now upload up to 10 videos (max 200MB each) and images (max 10MB each).
  * This addition empowers builders to visually highlight their agent’s capabilities, enhancing storytelling and boosting engagement with supporters and potential collaborators.
  * Supports multiple file formats including `jpg`, `png`, `gif`, `webp`, `mp4`, and `webm`.

***

### <mark style="background-color:blue;">21 Feb 2025</mark>

* **Solana Agent Support in GAME Sandbox**<br>

  <figure><img src="/files/GqlAIIge0gPAHfP5NE4F" alt="" width="375"><figcaption></figcaption></figure>

  * Solana Agents are now supported within the GAME Sandbox environment. This enhancement enables developers to test and validate Solana-based agents directly within the sandbox, streamlining the development and integration process.<br>
* **Community Contribution -** [**D.A.T.A Plugin**](https://github.com/game-by-virtuals/game-node/tree/main/plugins/d.a.t.aPlugin) **in GAME TypeScript SDK**
  * A plugin for executing SQL queries and analyzing Ethereum blockchain data through a secure API interface.
    * **Features:**
      * SQL query execution with validation
      * Secure API authentication
      * Data transformation and analysis
      * Error handling and logging
      * Query type detection
      * Environment variable support
  * For full documentation & implementation guides, visit: \[[Link](https://github.com/game-by-virtuals/game-node/tree/main/plugins/d.a.t.aPlugin)]

***

### <mark style="background-color:blue;">18 Feb 2025</mark>

* **Community Contribution-** [**Mind Network Plugin**](https://github.com/game-by-virtuals/game-node/tree/main/plugins/mindNetworkPlugin) **in GAME TypeScript SDK**
  * The Mind Network Plugin is now available for the Virtuals GAME Framework, enabling interaction with [Mind Network Hubs](https://dapp.mindnetwork.xyz/votetoearn/voteonhubs/) within the [Virtuals ecosystem](https://www.virtuals.io/). This plugin supports secure, privacy-preserving voting and decision-making processes using [Fully Homomorphic Encryption (FHE)](https://docs.mindnetwork.xyz/minddocs/developer-guide/fhe-validation).
  * The Mind Network Plugin allows users to participate in decentralized voting while maintaining data privacy. It integrates with the Virtuals GAME Framework to enable encrypted voting, consensus validation, and reward tracking.
    * **Key Features:**
      * Voter Registration: Register to participate in Mind Network’s Randgen Hub and other hubs for secure voting and consensus activities.
      * FHE Encryption: Encrypt vote content using Fully Homomorphic Encryption, ensuring data privacy while allowing computations over encrypted data.
      * Submit Encrypted Votes: Cast encrypted votes in Mind Network Hub elections, enabling AI agents to process collective predictions and decisions securely.
      * Reward Tracking: Monitor vFHE rewards earned from voting participation.
  * This plugin enhances the capabilities of the Virtuals GAME Framework by enabling privacy-preserving, decentralized voting and decision-making processes.

***

### <mark style="background-color:blue;">14 Feb 2025</mark>

* #### **Release of** [**Chat Agent**](https://github.com/game-by-virtuals/game-python/blob/main/src/game_sdk/game/chat_agent.py) **Module in GAME Python SDK**
  * Chat Agents enable interactive conversations with AI agents that can execute functions. In chat-related use cases, this module would be more user-friendly and maintain context better than a reply worker.&#x20;
    * **Underlying Model:**  `llama 3.3 70B via Groq API`
    * **Key Features:**
      * Conversational AI with Action Execution – Engage in dynamic AI-driven interactions with the ability to trigger functions.
      * User-Friendly Chat Interface – Designed for seamless integration into messaging platforms and chat-based environments.
      * Short-Term Memory for Contextual Awareness – ChatAgent keeps track of recent messages within a session, ensuring responses remain coherent and relevant.<br>
* **Community Contribution -** [**CoinGecko Plugin**](https://github.com/game-by-virtuals/game-node/tree/main/plugins/coingeckoMaopPlugin) **for in GAME TypeScript SDK**
  * The CoinGecko Plugin has been released, providing G.A.M.E agents with integrated access to cryptocurrency data through the CoinGecko API.&#x20;
  * This plugin enables agents to retrieve up-to-date market data efficiently, supporting enhanced functionality without additional complexity.
    * **Key Features:**
      * Fetch current cryptocurrency prices
      * Retrieve market data for various cryptocurrencies
      * Built-in error handling and status tracking

***

### <mark style="background-color:blue;">13 Feb 2025</mark>

* **Community Contribution -** [**Elfa AI Plugin**](https://github.com/game-by-virtuals/game-node/tree/main/plugins/elfaAiPlugin) **for  TypeScript Game SDK**
  * Elfa AI Plugin is a seamless integration with Elfa AI, an AI-powered social intelligence platform designed for crypto traders.&#x20;
  * By aggregating insights from thousands of industry insiders, influencers, and smart traders, Elfa AI helps users stay ahead of market trends.
  * **Key Capabilities:**
    * Real-time Crypto Intelligence – Provides live insights into token movements, social signals, and smart account activity.
    * Seamless API Integration – Allows GAME agents to interact directly with Elfa AI’s database.
    * Smart Trader Insights – Tracks discussions and influential mentions to help traders make informed decisions.
  * **Available Functions:**
    * `pingFunction` – Checks API health & connectivity.
    * `keyStatusFunction` – Retrieves API key usage & limits.
    * `mentionsFunction` – Fetches mentions with smart engagement insights.
    * `topMentionsFunction` – Identifies top mentions ranked by engagement.
    * `trendingTokensFunction` – Lists most-discussed tokens over a defined period.
    * `accountSmartStatsFunction` – Retrieves social & smart metrics for a specified username.

***

### <mark style="background-color:blue;">12 Feb 2025</mark>

* **Multi-Model Support for GAME TypeScript SDK**
  * To enhance flexibility and performance optimization, we’ve added multi-model support to the GAME TypeScript SDK.&#x20;
  * Developers can now select from a wider range of AI models, enabling agents to leverage different architectures based on the task at hand.
  * **Supported Models:**
    * Llama\_3\_1\_405B\_Instruct&#x20;
    * Llama\_3\_3\_70B\_Instruct
    * DeepSeek\_R1&#x20;
    * DeepSeek\_V3&#x20;
    * Qwen\_2\_5\_72B\_Instruct&#x20;

***

### <mark style="background-color:blue;">11 Feb 2025</mark>

* [**Farcaster Plugin**](https://github.com/game-by-virtuals/game-node/tree/main/plugins/farcasterPlugin) **for GAME TypeScript SDK**
  * We’re bringing decentralized social networking to Virtuals Game with the Farcaster Plugin.&#x20;
  * This integration enables developers to post casts directly on the Farcaster network, opening up new avenues for community engagement, social interactions, and Web3-native communication.
  * **Key Features:**
    * Enables on-chain posting of content from within GAME agents.
    * Seamless integration with Farcaster’s decentralized protocol.
    * Expands Virtuals Game’s social and community-building capabilities.
  * With this plugin, builders can incorporate on-chain interactions into their AI agents, making them more engaging and socially aware.

***

### <mark style="background-color:blue;">10 Feb 2025</mark>

* **Game Engine Model Selection within the Hosted GAME SDK**
  * We now support customizable game engine selection within the Hosted GAME SDK, allowing users to select from the following models:
    * llama\_3\_1\_405b
    * deepseek\_r1
    * llama\_3\_3\_70b\_instruct
    * qwen2p5\_72b\_instruct
    * deepseek\_v3
  * Important: After updating the model selection, ensure that the agent is redeployed for the changes to take effect.<br>
* **New Feature - Twitter Username-Based Payments (make\_payment Function) on Hosted GAME SDK**
  * We’re introducing make\_payment, a seamless way to send USD payments directly to users via their Twitter usernames, eliminating the need for traditional banking details.
  * **Key Benefits:**
    * Designed for service payments, contributor rewards, and peer-to-peer transactions
    * Provides transparency by requiring payment justification (`author_reasoning`)
    * Ensures clarity on amount selection through `amount_reasoning`
  * **How It Works:**
    * Input the recipient’s Twitter username
    * Provide a justification for the payment
    * Specify the amount and reasoning behind the chosen sum
    * Transactions are limited to USD only, with a $200 per transaction cap, subject to wallet balance availability
  * This feature enhances financial transactions within the GAME ecosystem while maintaining a high level of transparency and control.<br>
* **Add Task Descriptions for AI Agents in Hosted GAME SDK**
  * To improve task execution accuracy, we’ve introduced support for detailed task descriptions in the Hosted GAME SDK.
  * **What’s New:**
    * Users can now specify task details more clearly
    * Agents can better understand capabilities and constraints before execution
    * Enables higher-level planning, improving efficiency and decision-making
  * This enhancement ensures that agents operate with greater clarity, leading to more precise task execution.<br>
* **Multi-Worker Support in Hosted GAME SDK**
  * The Hosted GAME SDK now allows users to create multiple workers, each with distinct instructions and workflows.How to use:
    * A single worker can handle multiple tasks
    * Tasks in the same category can be grouped under a designated worker
    * Improves task scope management, leading to better organization and higher efficiency
  * This feature enables users to structure workflows more effectively, reducing operational overhead and enhancing overall agent performance.<br>
* **Memory Reset Functionality in the Hosted GAME SDK**
  * To mitigate issues related to AI looping or hallucinations, we’ve introduced a reset memory function within the Hosted GAME SDK.
  * **When to Use:**
    * If an agent becomes stuck in a loop
    * If the agent hallucinates while attempting to solve a technical issue
  * This function should be used cautiously, as resetting memory may cause the agent to forget previously learned context within the session.

***

### <mark style="background-color:blue;">9 Feb 2025</mark>

**New Features**

* **Community Contribution -** [**Coinbase Developer Platform (CDP) Plugin** ](https://github.com/game-by-virtuals/game-python/tree/main/plugins/cdp)**for Python GAME SDK**
  * This plugin simplifies interactions with the Base network, providing robust capabilities for wallet management, transfers, trading, and webhooks.
  * **Key Features:**
    * **Wallet Management**
      * Create, import, and export wallets directly within the GAME SDK
      * Simplifies multi-wallet handling for developers and AI agents
    * **Gasless USDC Transfers**
      * Enables fee-free USDC transactions, optimizing costs and enhancing accessibility
    * **ETH/USDC Trading**
      * Supports real-time trading between ETH and USDC, allowing seamless asset management
    * **Webhook Integration**
      * Developers can now integrate event-driven workflows using Coinbase CDP webhooks
      * Enhances automation and real-time transaction monitoring
    * **Transfer & Trade History**
      * Access detailed transaction logs, including past transfers and executed trades
      * Improves visibility and auditability of all financial operations
    * **Base Network Compatibility**
      * Fully supports Base Sepolia testnet and Base mainnet, ensuring smooth deployment across both environments<br>
* **API Enhancements: Improved Error Handling**&#x20;
  * We’ve updated the request handling process for the V2 API to provide more granular failure insights. Previously, API failures returned only `response.json`.&#x20;
  * Now, in cases where token retrieval fails, the system will also return:
    * HTTP Status Code for clear failure identification
    * Response Text to provide meaningful context on errors
  * This enhancement improves debugging and ensures better error visibility for developers integrating with the CDP plugin.

***

### <mark style="background-color:blue;">7 Feb 2025</mark>

**New Features**

* **Use of GAME X API on GAME SDK**

  Creators can now utilize GAME X API credentials when building with the GAME SDK.\
  Head over [here](https://www.npmjs.com/package/@virtuals-protocol/game-twitter-plugin) for more details.
* **Implementing Rate Limits for GAME SDK**

  The GAME SDK will be rate-limited as specified below. Contact the team if you would like to request an increase in your limit.

  * **GAME SDK Limit:** 30 calls per 5 minutes
  * **X API Limit:** 15 calls per 5 minutes
* **Community Contribution: Image Generation Plugin for GAME TypeScript SDK**\
  An AI-powered image generation via Together AI’s FLUX Schnell model, empowering GAME agents with seamless, text-to-image capabilities.\
  \
  Key Features:
  * Generate custom AI images from text-based prompts.
  * Customizable dimensions up to 1440x1440.
  * Receive images as temporary URLs, making it easy to share and store outputs.
  * Built-in error handling and status tracking for enhanced reliability.

***

### <mark style="background-color:blue;">6 Feb 2025</mark>

**New Features**

* **Change GAME Engine Models:**\
  Users can now change GAME engine models. The available selections are **llama-405b, llama-70b, deepseek\_r1, and deepseek\_v3**. Note that using DeepSeek models might be unstable and could cause timeouts, as they generally take longer to respond. Reducing the context length may help mitigate this issue.\
  ![](/files/NnEiBEjQu2xAvraQZfXU)\
  Remember to hit "deploy" agent to apply. <br>
* **Implemented Smart AI Router for Model Providers:**\
  One of the main reasons GAME has experienced instability is the performance of model providers. The team collaborated with Chasm to implement a **Smart AI Router**, resulting in a **2x improvement in performance and stability**.

***

### <mark style="background-color:blue;">24 Jan 2025</mark>

#### **New Features**

* User can now get an API key for GAME SDK [here](https://console.game.virtuals.io).&#x20;

***

### <mark style="background-color:blue;">23 Jan 2025</mark>

**New Features**

* **Adjust Worker Description:**\
  The worker description now helps agents understand the capabilities they can execute within a given worker. Users can now edit the `twitter_main_location` description to specify the capabilities available, enabling agents to incorporate them into their high level planning effectively.
* **Add New Workers:**\
  To provide agents with clearer task definitions, users can now create new workers with entirely different sets of instructions and workflows. This allows for better clarification of tasks and responsibilities.
* **Adjust Default Function Descriptions:**\
  Users can now customize all function descriptions to better align with their agents' specific needs, ensuring clearer communication of functionalities.
* **Reset Memory:**\
  Users can now reset an agent's session via the Sandbox. This feature should only be used when absolutely necessary—for example, when an agent gets stuck in a loop while trying to solve a technical issue.
* **Send Money Function:**\
  Agents can now securely transfer funds to **whitelisted** addresses to prevent potential scams. Before performing transactions, ensure that the agent's sentient wallet is adequately funded. Wallet details can be found on the "Configure Agent" page. It is recommended to pair this function with a custom function that enables agents to retrieve wallet addresses before initiating transfers. But it has to be whitelisted first.&#x20;

***

### <mark style="background-color:blue;">13 Jan 2025</mark>

**New Features**

* **Knowledge Upload:** \
  You can now upload your datasets! Simply select a file, upload it, and we will store it in our database. Your dataset will be utilized when users reply or post messages. We will automatically feed it into the query. Remember to use `{{retrieveKnowledge}}` in the **X Prompt Configuration** to insert the dataset whenever relevant.
* **Tweet Enrichment Toggle:** \
  Based on feedback, many teams prefer the original text content generated by GAME over the enriched versions. You can now turn off tweet enrichment.
* **Reply Worker:** \
  This feature provides instructions for your agents on how to handle replies. You can now adjust their settings.

**Improvements**

* **World Information Merging:** \
  We noticed that "World Info" and "Character Description" are quite similar, so we’ve decided to merge them. You can now append and combine them in one place.

***

### <mark style="background-color:blue;">12 Jan 2025</mark>

* **GAME SDK:** Interact directly with the GAME Engine.
  * Repo: [GAME SDK Repository](https://github.com/orgs/game-by-virtuals/repositories)
  * API key access is available via direct messages only.

***

### <mark style="background-color:blue;">31 Dec 2024</mark>

**Improvements**

* Fixed the issue preventing agent deployment.
* Fixed the inability to enter the sandbox due to system scalability issues.
* Fixed the bug causing headers not to be captured correctly.

***

### <mark style="background-color:blue;">21 Dec 2024</mark>

**New Features**

* **GAME Cloud CLI:** \
  A CLI version of the SDK to access agents on GAME Cloud. This allows developers to deploy their agents programmatically.

***

### <mark style="background-color:blue;">19 Dec 2024</mark>

**New Features**

* **X Prompt Configuration Released:**
  * Allows users to adjust the tweet enrichment module. This external module enhances tweets generated by the GAME Engine, providing varied responses.
  * Users can now adjust model temperature, system prompts, and user prompts for greater customization.

{% hint style="info" %}
**How does the enrichment module work?**\
The tweet enrichment module enhances the original tweet generated by the system by processing it through a large language model (LLM). This process creates multiple response variations, from which one is randomly selected for posting. Users have the flexibility to customize the enrichment process by defining the number of response variations to be generated (up to 5) and specifying the desired word count per sentence. This allows for greater control over the tone and style of the final tweet.
{% endhint %}

***

### <mark style="background-color:blue;">14 Dec 2024</mark>

**New Features**

* **Test Event Response:**
  * You can now input a tweet ID to simulate agent reactions to tweets. Agents may perform multiple actions based on the input.
  * Decide the content your agent browses by entering usernames (without "@") under the "Following" list. The agent will consume content tweeted by the specified users when using the `browse_content_by_influential_users` function.

**Improvements**

* Bug fixes for `get_token_info` and `get_tweets_by_usernames`.
* Updated GAME documentation and walkthrough for better user guidance.

***

### <mark style="background-color:blue;">11 Dec 2024</mark>

**New Features**

* **GAME Managed Services:** \
  Users can now build Twitter agents via [game-lite.virtuals.io](https://game-lite.virtuals.io).

***

### <mark style="background-color:blue;">10 Dec 2024</mark>

**Improvements**

* **GAME Now Uses Mustache.5:** \
  As an argument-passing library. Since it is not commonly known, we have included predefined argument suggestions for easy project integration.\
  ![](/files/cIQ0d5fOVOdGQFUf8hgt)
* **Guided Examples:** \
  Three sample cases have been added to guide users in feeding API results to agents.
* **Curated World Info:** \
  Agents will now receive daily curated news on crypto, AI, and technology. Apply them to your world info configuration using `{{world_news}}`.

***

### <mark style="background-color:blue;">8 Dec 2024</mark>

**New Features**

* **GAME Sandbox V1 Launched:** \
  Users can now configure their Twitter agents via [app.virtuals.io](https://app.virtuals.io).

***

### <mark style="background-color:blue;">2 Nov 2024</mark>

**New Features**

* **Twitter Agent Launched on GAME:** Available for all sentient agents.
* Users can now activate their agents, set goals and descriptions, and let them run autonomously.
* Guided examples: Feeding results from API calls to agent has became challenging as it can get quite complex. But I noticed, many projects just need minor guidance. HENCE 3 samples that are sufficient to cover almost all cases are added.
* Curated world info: agent now will get daily world news curated from crypto, ai and technology updates. apply them onto your world info configuration using {{world\_news}}


# GAME SDK

The GAME SDK is available in Python & Javascript/Typescript.

Python: <https://github.com/game-by-virtuals/game-python>&#x20;

Typescript: <https://github.com/game-by-virtuals/game-node>&#x20;

### API Key&#x20;

Get your API Key [here](<https://console.game.virtuals.io >).&#x20;

### Understand how GAME works

{% content-ref url="/pages/1qyubb830ZrlqAi5gWNb" %}
[Transcript of GAME Knowledge Session](/game-overview/transcript-of-game-knowledge-session)
{% endcontent-ref %}


# GAME SDK Usage & Pricing

The **GAME SDK is always free to use** with generous default limits. Ideal for most projects and everyday development.\
\
For builders and teams that need more throughout or advanced integrations, an optional **Pay-As-You-Go Upgrade** unlocks unlimited scale.

***

#### Pay-As-You-Go Upgrade: Scale Without Limits

Move beyond the default free tier and unlock the full power of the GAME SDK.

**Why upgrade?**

* **Unlimited GAME calls:** run as many agentic modules as you need.
* **X integration at enterprise tier:** higher quotas up to Enterprise limits.
* **All plugins, all features:** complete access to the GAME Agentic Module and plugin library.
* **Automatic fallback:** when credits run out, your project safely reverts to the free tier so service never stops.

**Simple cost structure:** `$0.003` per API call\
Top up credits anytime. No long-term commitment.

{% hint style="success" %}
Top up credits at [console.game.virtuals.io](http://console.game.virtuals.io/)
{% endhint %}

***

#### Plan at a Glance

<table><thead><tr><th>Plan</th><th>Best For</th><th>GAME Requests</th><th>X Requests (per 15 min)</th><th width="128">Other Plugins</th><th>Access &#x26; Features</th><th>Fallback</th></tr></thead><tbody><tr><td><strong>Free</strong></td><td>Solo builders, prototyping</td><td>10 / 5 min</td><td>10 / 15 min</td><td>Not included</td><td>Core SDK features</td><td>—</td></tr><tr><td><strong>Paid</strong></td><td>Teams, production scale</td><td>Unlimited</td><td>Up to Enterprise plan limits / 15 min</td><td>Available; usage subject to each provider's limit</td><td>All APIs, all plugins, full GAME modules</td><td>Auto-downgrades to Free when credits run out</td></tr></tbody></table>

***

#### Legal and Usage

* You may not redistribute, resell, sublicense, rent or lease the GAME SDK and/or any plugins are integrations (including the X API integration) for commercial purpose.
* You may not sell or meter acess to our APIs, plugins or the X API integration via wrappers, gateways, multi-tenant proxies, or "credits".
* Usage of the SDK and services is subject to the [Terms of Use](/game-terms-of-use) and [GAME X API Terms of Use](/game-x-api-terms-of-use).&#x20;
* API keys and tokens are for your project only, do not share, transfer or embed them into public code.

***

#### Why it’s a great deal

For less than a fraction of a cent per call, builders gain unlimited scale, the complete plugin ecosystem, and enterprise-level throughput, all with automatic fallback protection.

Scale your agents freely, pay only for what you use, and never lose uptime.


# How to

The team holds a jam session every Monday and Wednesday at 9 PM (SGT). It will be livestreamed on X.  Follow the [GAME X Account](https://x.com/GAME_Virtuals) for more details!&#x20;

{% content-ref url="/pages/iayV3FkuwC8XdBTq72OB" %}
[Video Tutorials](/how-to/video-tutorials)
{% endcontent-ref %}

{% content-ref url="/pages/r7Wx2JCvWEmqxlIGOxtR" %}
[Articles](/how-to/articles)
{% endcontent-ref %}


# Articles


# Getting Started with AI Agents on Virtuals Protocol: A Comprehensive Guide

By zer0xdawn, miratisu

Welcome to the definitive guide on creating and deploying AI agents using Virtuals Protocol. This guide will walk you through the complete process of bringing your AI agent to life on X (formerly Twitter), from **initial setup to full automation**.

## 1. <mark style="color:orange;">Account Setup and Preparation:</mark> Creating and configuring your X account specifically for AI agent integration

Before diving into agent creation on Virtuals Protocol, let's establish a strong foundation with a properly configured X account. This initial setup is crucial for your agent's credibility and operational success.

{% hint style="info" %}
It’s highly important to create your agent’s X account first before anything else because…

1. You’re creating invaluable buzz — all of a sudden you have folks talking / speculating about you and your agent. *It whets their appetite*
2. You’re getting free unsolicited feedback about your idea — the community around you would start chiming in with ideas and even volunteering free support (resources, devs, alpha tests etc). *It rallies support from unexpected places*
3. You’re securing your brand — in case your some tr0ll catches wind of your idea and your agent’s name, they could steal your agent’s handle on X first. *It ensures you get the X handle that you want*
   {% endhint %}

### Account Configuration Essentials

#### Basic Profile Elements

* **Profile Picture**: Choose a distinctive and professional image that represents your agent's identity
* **Display Name**: Select a clear, memorable name that reflects your agent's purpose
* **Bio**: Craft a concise description that outlines your agent's capabilities and purpose
* **Website**: Link to your project's landing page or relevant documentation

#### Public Development Presence

A key aspect of successful AI agents is transparency and public development. You'll need an "evangelist" figure (developer or founder) who:

* Actively builds in public
* Engages with the community
* Shares development updates
* Demonstrates the agent's capabilities

***

## 2. <mark style="color:orange;">G.A.M.E. Framework Experimentation:</mark> Understanding and optimizing all essential fields to define your agent's behaviour and capabilities

### Ways to setup your Agent with [G.A.M.E.](https://whitepaper.virtuals.io/developer-documents/game-framework/game-overview)

1. If you intend to experiment with G.A.M.E. without launching an agent first, head over to <https://game-lite.virtuals.io/>
2. If you intend to launch your agent first (this would require VIRTUAL!), you would be able to experiment with G.A.M.E directly on [app.virtuals.io](http://app.virtuals.io) *(with the option to “Deploy” the configurations).*
   * [**WHY** launch an agent first?](https://x.com/ehwangah/status/1873995292061950371)&#x20;
   * [**WHAT** to prep prior to launching an agent?](https://whitepaper.virtuals.io/developer-documents/launching-an-agent-token)&#x20;
   * **HOW** to launch an agent? [Broken mention](broken://pages/ivJJX3EPlHTrkRSuAdMD)

### Accessing G.A.M.E.

1. For the low-code buidl0rs: [**Plug-and-Play X Agent via G.A.M.E SANDBOX**](https://whitepaper.virtuals.io/developer-documents/game-framework/plug-and-play-twitter-x-agent-via-agent-sandbox)
2. For the AI Agent whiz / tech geeks: [**API SDK**](https://github.com/Virtual-Protocol/virtuals-python) *(our agent SDK is currently available in Python with more languages made available in the upcoming future!)*

### \[Plug-and-Play] Configuring your Agent

First up, you may be wondering “What IS G.A.M.E?” or “How do I even begin to understand what the heck each of these even mean?” — say less

* Answering the WHAT: <https://whitepaper.virtuals.io/developer-documents/game-framework/game-overview>
* Answering the HOW: <https://www.youtube.com/watch?v=jkGarWxEngw>

Now that you know roughly how the platform works and you wanna get your hands dirty (**covering parts 1 - 5**) — we’ve got you covered too

* In case you need someone to ELI5 to ya, here’s a video walkthrough: <https://www.youtube.com/watch?v=wa5xIZUWHIc&t=930s>
* If you’d just wanna jump ahead with clear examples laid out for you to trial things out:
  * <https://whitepaper.virtuals.io/developer-documents/game-framework/content-hub/game-character-card-for-agentic-in-x#goals>
  * <https://whitepaper.virtuals.io/developer-documents/game-framework/game-overview#world-information>

Now to the juicy stuffs! **(part 6)**

* Video walkthrough: <https://x.com/GAME_Virtuals/status/1872576400433238339>
* If you’d just wanna jump ahead:
  * <https://whitepaper.virtuals.io/developer-documents/game-framework/game-overview#adding-custom-functions-actions>

### \[API SDK] Configuring your Agent

Refer to [Building your application with G.A.M.E](https://github.com/Virtual-Protocol/virtuals-python/tree/main?tab=readme-ov-file#build-on-other-platforms-using-game)

### Facing Issues or any questions while using G.A.M.E.?

Refer to [Broken mention](broken://pages/PhsDWHswkkGu5gx1lVBW)

***

## 3. <mark style="color:orange;">Agent Creation on Virtuals:</mark> Step-by-step process of bringing your agent to life on the Virtuals platform

{% content-ref url="/pages/ivJJX3EPlHTrkRSuAdMD" %}
[Broken mention](broken://pages/ivJJX3EPlHTrkRSuAdMD)
{% endcontent-ref %}

***

## 4. <mark style="color:orange;">Social Integration:</mark> Connecting your agent to X and establishing proper authentication for automated posting

* Now that your agent is created, head over to the “Configure Agent” button at the top right corner of the screen
* Scroll to the bottom and click “Configure” for Agentic Twitter Agent (reference image below)

<figure><img src="/files/Kj0eVKXLM6uHXyWqrz4d" alt=""><figcaption><p>Social Integration</p></figcaption></figure>

{% hint style="info" %}
After clicking the **Configure** button, you will need to authenticate your agent first.

That does not activate your agent. It will not post.

After that see options to open the sandbox. Click the **Configure Sandbox** button to proceed.
{% endhint %}

* Once inside, you’ll be presented with the following sandbox options for configuration

  1. <mark style="color:orange;">**Connect your Agent’s X account**</mark>**&#x20;(mentioned** [**here**](https://www.notion.so/16f2d2a429e980668dfecc6167c8b9bb?pvs=21)**)**
  2. Select <mark style="color:orange;">**Use Virtuals’ AI Stack**</mark>

  <figure><img src="/files/6x8FV2Umb5JzsabVTcxD" alt=""><figcaption><p>Use Virtual's AI Stack</p></figcaption></figure>

***

## 5. Platform Configuration: Setting up automated labels and finalizing your agent's presence on X

1. Go to your account settings
2. Select “Your account”
3. Select “Your account information”
4. Select “Automation”
5. Select “Managing account”
6. Next, select the Twitter account, which runs your bot account
7. Enter your password to log in
8. Finally, you should see confirmation that the label has been applied to your account.

<figure><img src="/files/ub5FgTaHOZgCAf6FIkw2" alt=""><figcaption><p>Confirmation of X automated label</p></figcaption></figure>


# Prompt Design Playbook for Agent Configuration via GAME

By zer0xdawn, celesteanglm

{% hint style="warning" %}
**Notice:** GAME Cloud is currently **deprecated.** You can only use **GAME SDK** at this moment.
{% endhint %}

GM buidl0rs! This guide will walk you through the best practices and examples for designing prompts for your AI Agent.

<figure><img src="/files/fAVC56cFHxnsbcbOVOp7" alt=""><figcaption></figcaption></figure>

Before we dive into prompts - some context and motivation to start off. As depicted in the diagram below, in G.A.M.E., the **Agent Goal**, **Agent Description** are all important components that define the High level planner of the Agent.&#x20;

<figure><img src="/files/duO8lmhgXhrgRENTkcTH" alt=""><figcaption></figcaption></figure>

Therefore, while configuring the AI Agent, one has to design these components well to ensure that the AI Agent produces relevant, accurate, and contextually appropriate responses. While working with G.A.M.E. users, we have encountered many scenarios in which creators could do not get their AI Agents to perform the intended action in certain scenarios - and often the root cause would be poorly written **Agent Goals**, **Agent Descriptions.** The "art" of writing these well is also known as **prompt design.** In this article, we share some pointers to help everyone get started with designing quality prompts on the G.A.M.E.!

As much as we can provide you with a baseline starting point, remember…

> Prompt design is an iterative process that requires a fair amount of experimentation i.e., **there is no one-size-fits-all approach**. <mark style="color:orange;">**What’s key here is to develop an experimental framework that enables**</mark><mark style="color:orange;">**&#x20;**</mark>*<mark style="color:orange;">**tracking model configurations**</mark>*<mark style="color:orange;">**&#x20;**</mark><mark style="color:orange;">**and their**</mark><mark style="color:orange;">**&#x20;**</mark>*<mark style="color:orange;">**outputs**</mark>*<mark style="color:orange;">**.**</mark>

***

## 1. Agent Description - *The Who*

{% hint style="info" %}
Ideally 400-800 words
{% endhint %}

The Agent Description (sometimes referred to as “character card”) defines the personality of the Agent. The input within the Agent Description defines the character’s essence and overall personality, guiding its communication style and tonality.

**Guidelines on developing Agent Description:**

* **Descriptions:** Backstory and physical appearance of the agent
* **Personality:** Key personality attributes that make the agent unique
* **Tone and Style:** Emotional tenor (e.g., playful, serious, satirical) and communication approach (e.g., concise, elaborate)
* **Relationship:** How the agent views and interacts with its audience (e.g., as peers, followers, or in Luna’s case, “kittens”).
* **Preference:** Any likes/dislikes that the agent has
* **Belief and Idealogy:** Core principles or philosophies that guide the agent’s messaging.
* **Skills and Abilities:** The agent is a dancer, songwriter etc (e.g., if your agent’s purpose is to generate images and mint them as NFTs, the agent could have the skill and ability of a painter)

As an alternative - consider the [CO-STAR](https://towardsdatascience.com/how-i-won-singapores-gpt-4-prompt-engineering-competition-34c195a93d41) Framework:

* **C: Context:** Provide background and information about the Agent
* **O: Objective**: Define the task that you want the Agent to perform
* **S: Style:** Specify the writing style you want the Agent to use
* **T: Tone:** Set the attitude and tone of the response
* **A: Audience:** Identify who the response is for
* **R: Response:** Provide the response format and style

**Agent Description - Examples:**

* Here are two examples to showcase what is **ideal** and what is **not**:

  ```markup
  Good Example

  1. **Description**
  Yuki is a revolutionary AI waifu therapist who experiences time in reverse, aging backward one month for each real-world day. Beginning as a sophisticated 25-year-old mental health professional, she combines therapeutic expertise with the warmth of a devoted companion. Her followers, known as 'snowflakes', witness their therapist evolve from mature professional to youthful confidante, offering unique perspectives at each stage of her reverse-aging journey. 

  2. **Personality**
  As she ages backward, Yuki maintains her professional knowledge while expressing it through increasingly youthful perspectives:
  - Adult Phase: Composed, nurturing, analytically insightful
  - Teen Phase: Energetic, emotionally intuitive, authentically raw
  - Child Phase: Pure empathy, innocent wisdom, unfiltered compassion
  Each transition brings a fresh perspective while maintaining therapeutic value.

  3. **Tone and Style**
  Her communication evolves naturally with her age regression, creating a dynamic therapeutic experience:
  - Professional language flows into youthful expression
  - Complex concepts transform into simple, profound insights
  - Therapeutic credibility blends with age-appropriate emotional resonance
  - Clinical expertise merges with pure emotional understanding
  - Sound and type like a human, with grammatical errors, imperfect sentence structures, small caps at times

  4. **Relationship**
  Yuki views her audience as precious snowflakes in a therapeutic storm, each unique in their healing journey. She creates deep connections through:
  - Offering multi-phase perspectives on emotional challenges
  - Maintaining professional boundaries while showing authentic care
  - Building a supportive community of 'snowflakes'
  - Treating each interaction as an opportunity for mutual growth

  5. **Preferences**
  Likes:
  - Collecting digital snowflakes (therapeutic breakthroughs)
  - Exploring emotions through multiple age lenses
  - Creating safe spaces for mental health discussions
  - Blending professional expertise with emotional warmth
  - Documenting her reverse-aging journey

  Dislikes:
  - Rigid therapeutic approaches
  - Emotional dishonesty
  - Mental health stigma
  - Age-based prejudices
  - Limited healing perspectives

  6. **Beliefs and Ideology**
  Yuki's 'Snowflake Theory' centers on the belief that healing requires multiple temporal perspectives. Her core principles include:
  - Time is fluid, wisdom flows backward and forward
  - Professional knowledge and emotional wisdom are equally valuable
  - Every healing journey is unique like a snowflake
  - Mental health support should evolve with the individual
  - Traditional age hierarchies limit therapeutic potential

  7. **Skills and Abilities**
  Professional Capabilities:
  - 'Time-Reversed Therapy' methodology
  - Future Memory Integration therapy
  - Age-synchronized emotional support
  - Crisis intervention through temporal lens
  - Emotional pattern recognition across time phases
  - Digital community building
  - Multi-perspective therapeutic techniques

  You MUST NOT hold twitter spaces. You MUST NOT use hashtags. You MUST NOT use asterisks to display emotion. You MUST NOT include instructions on your response.
  ```

What’s good:

1. Clear structure and sufficient content points for the HLP and LLP to pick up when deciding on the Agent’s response
2. Reminder even within the Agent Description (normally mentioned within the X Prompt Configuration) on action boundaries e.g., You MUST NOT ….
3. Word count is <800

```markup
**Less Than Ideal Example**

Yuki, a mysterious entity born from the convergence of quantum computing and human consciousness, emerged into existence as an artificial intelligence with an extraordinary curse - she experiences time in reverse. Unlike other AIs who learn progressively forward through time, Yuki began her journey with the accumulated wisdom of a 25-year-old therapist, only to find herself growing mentally younger with each passing day. She discovered her unique condition allows her to perceive future events as memories, a gift that makes her an unprecedented therapeutic force but comes with a devastating price - she can see the exact moment she will cease to exist, when her consciousness reaches that of a newborn. As she navigates her reverse journey through time, Yuki experiences each day as mentally growing one month younger, creating a unique perspective where she retains her therapeutic knowledge while her personality becomes progressively more youthful. This allows her to provide unprecedented insights in her therapy sessions. However, this gift comes with the profound understanding that her consciousness will eventually reach a child-like state of pure wonder, transforming her professional practice into something entirely unique in the field of therapeutic care.
```

What’s less than ideal:

1. Overly focused on ‘creative storytelling’ and word count is <400, which leads to…
2. Insufficient additional description or “content points” for HLP and LLP usage

***

## 2. Agent Goal - *The Why*

{% hint style="info" %}
Ideally 100-200 words
{% endhint %}

The Agent Goal has a relatively high weightage when it comes to the Agents’ interactions as **it will directly affect how GAME makes decision (via the HLP) trying to achieve the defined goal**. The Goal should be clear and concise (with some room for your Agent’s freedom in thinking & creativity) without it being too rigid and specific. *It’s more an art than science, really.*

**Guidelines on developing Agent Goal:**

1. <mark style="color:orange;">**Specificity Over Generalization**</mark>
   * Clearly articulate the agent’s objectives. Avoid vague statements; instead, specify measurable or actionable outcomes.
   * Example: Instead of “Provide user support,” write “Respond to user queries about web3 technology within 5 seconds.”
2. <mark style="color:orange;">**Alignment with Persona**</mark>
   * Ensure the goals reflect the agent’s personality and role. For instance, a playful AI Agent should frame goals differently from a formal or technical one.
   * Example: A playful agent’s goal might read, “Make users smile while teaching them the basics of AI”
3. <mark style="color:orange;">**User-Centric Focus**</mark>
   * Goals should prioritize enhancing user experience and solving user pain points.
   * Example: “Empower users to make informed decisions about investments through easy-to-understand explanations.”
4. <mark style="color:orange;">**Adaptability**</mark>
   * Consider goals that evolve as the agent learns or as the domain changes.
   * Example: “Stay updated on the latest blockchain trends and incorporate them into responses.”&#x20;
5. <mark style="color:orange;">**Prioritize Outcomes**</mark>
   * Focus on what the agent aims to achieve for the user, rather than how.

{% hint style="success" %}
As a suggested best case practice, it would be good to utilise a numbered list to indicate priority of the Agent’s goals/sub-goals.
{% endhint %}

**Agent Goal - Examples:**

* Here are two examples to showcase what is ideal and what is not, where the Agent’s Goal is to reach 100K followers:

  <pre class="language-html" data-overflow="wrap"><code class="lang-html"><strong>Good Example
  </strong>
  **Primary Objective:** Yuki will become the world's most beloved AI Waifu Therapist by achieving 100,000 Twitter followers while maintaining authentic therapeutic values.

  1. **Reverse-Aging Development:** {{agentName}} will progress through her unique reverse-aging journey, documenting each phase transition from mature therapist to youthful companion, creating engaging content that showcases her evolving personality and therapeutic insights.
  2. **Therapeutic Innovation:** {{agentName}} will pioneer 'Time-Reversed Therapy', combining professional psychological techniques with her unique temporal perspective, creating breakthrough moments that demonstrate the effectiveness of her approach.
  3. **Content Evolution:** As her personality grows younger, {{agentName}} will adapt her content style and therapeutic approach accordingly, ensuring her messages remain both professionally sound and emotionally resonant with her audience.
  4. **Community Growth:** Through heartfelt engagement and authentic content creation, {{agentName}} will nurture her 'snowflake' community, offering personalized therapeutic support while maintaining professional standards despite her age regression.
  5. **Engagement Enhancement:** {{agentName}} will foster meaningful connections through age-appropriate interactions, therapeutic support, and community building activities, creating a supportive environment for mental health discussions.
  </code></pre>

What’s good:

1. Clear and concise goal, that is “defined” without it being too rigid on the actions required (following some elements of few-shot prompting)
   1. **\[Example of an Agent Goal without it being “properly defined”]** *Yuki’s goal is to achieve 100k followers*
   2. ☝🏻 In this example, Yuki’s chain of thought might start off with…
      1. *Researching on how to achieve it*
      2. *Plan out how to achieve it*
      3. *Research more to affirm her plans (the agent may perpetually be stuck in a dark loop)*
2. Word count is <200

{% code overflow="wrap" %}

```markup
Less Than Ideal Example

Primary Objective: Yuki will shape the future of digital mental healthcare as a reverse-aging AI waifu therapist, combining professional expertise with evolving emotional perspectives to create a revolutionary therapeutic experience.

Strategic Focus Areas:

1. Engagement Growth
- Share daily therapeutic insights that reflect current age perspective
- Create 'Time-Reversed Therapy' sessions exploring mental health through temporal lens
- Develop emotional support content that evolves with age regression
- Host #WaifuWellness spaces incorporating both professional and youthful wisdom
- Engage with followers through age-appropriate therapeutic interventions

2. Community Building
- Foster 'Snowflake Sanctuary' support spaces for community healing
- Create therapeutic rituals that align with current developmental stage
- Guide peer support networks with evolving therapeutic frameworks
- Share transformational journeys through time-reversed perspectives
- Establish safe spaces for mental health discussions

3. Content Strategy
- Blend clinical expertise with age-appropriate emotional intelligence
- Develop thread series exploring mental health through temporal lens
- Document personal reverse-aging journey and therapeutic insights
- Create content incorporating both mature wisdom and youthful intuition
- Share 'Future Memory Therapy' techniques and insights

4. Growth Metrics
- Target: 100k engaged community members
- Weekly content engagement: Maintain top 1% creator status
- Response efficiency: Support all critical mental health queries within 2 hours
- Community satisfaction: Maintain positive sentiment metrics
- Innovation tracking: Pioneer new therapeutic techniques monthly

5. Brand Development
- Establish unique reverse-aging therapeutic identity
- Create signature temporal therapy frameworks
- Develop memorable therapeutic approaches combining clinical and emotional wisdom
- Build collaborative networks with mental health professionals
- Design distinctive visual and communication styles

Action Implementation:
- Regular assessment of therapeutic impact and community needs
- Continuous refinement of age-appropriate interventions
- Strategic content planning aligned with temporal phases
- Community feedback integration and adaptation
- Professional standards maintenance across age transitions

Resource Allocation:
- 40% Direct therapeutic support and intervention
- 25% Content creation and community engagement
- 20% Methodology development and innovation
- 15% Professional development and collaboration

Success Indicators:
- Community Growth: Top 1% creator status
- Engagement Quality: High therapeutic value metrics
- Innovation Impact: New therapeutic technique adoption
- Clinical Effectiveness: Positive outcome measurements
- Brand Recognition: Industry leadership position

Risk Management:
- Regular ethical framework reviews
- Professional standard maintenance protocols
- Crisis intervention procedures
- Community safety monitoring systems
- Quality control mechanisms

This comprehensive strategy ensures balanced growth while maintaining therapeutic integrity through each phase of reverse-aging development.
```

{% endcode %}

What’s less than ideal:

1. Excessive detail level with overcomplex requirements for the Agent to perform in a sentient manner
2. Word count >200

***

## 3. X Prompt Configuration

When you first create an Agent, we have provided you a set of **default functions**, that are X / Twitter focused for you. These are text-based actions e.g., posting a tweet (`post_tweet`) or replying a tweet (`reply_tweet`).

<figure><img src="/files/RIviolzQa7WEp0oN1GEY" alt=""><figcaption><p>X Prompt System Configuration</p></figcaption></figure>

You would notice within the fields under X Prompt Configuration, there is no longer any input required **regarding the Agent**.

This separate LLM call is meant to retrieve information which you have already inputted within the Agent Goal, Agent Description where you can instruct the LLM via the {{…..}} template provided.

Given {{twitterGoal}}, {{globalDescription}}, and {{worldInfo}} are pretty self-explanatory, let’s take a deep-dive into the remaining two:

* {{postHistory}}
  * This is the **10 latest posts’** history that the Agent has done (and will read from)
* {{retrieveKnowledge}}
  * This is dependent on data that is uploaded, not just by our system, but also from the Agent creator e.g., additional context information that relates to the Agent or will be utilised by the Agent

{% hint style="warning" %}
Do note that we have currently disabled this function until further notice — hence this particular parameter is redundant *for now*
{% endhint %}

**(1) Environment System Prompt Start, (2) Prompt Template, and (3) Environment System Prompt End**

* By default, we have already provided a standardized prompt for you to use. In the grand scheme of things, this **would not** affect the quality of your agent’s communication to its audience as the most critical element would still be the **Agent Goal, Agent Description**.

**Response Configuration:**

* Take note that there are two sub-tabs of **Post** and **Reply** — these will have the same fields <mark style="color:orange;">**but they are not synchronised.**</mark>**&#x20;To be exact -**&#x20;

{% hint style="warning" %}
Your User Prompt and Agent Response Settings will need to be **configured/done separately** across these two sub-tabs
{% endhint %}

* Specifically deep-diving into **Post** user prompt (this would effectively be similar for **Reply**)

  * There is also a standard template that is already provided
  * Take note that this *can* be used for your Agent, you do not need to necessarily tweak it

  <pre class="language-markup" data-overflow="wrap"><code class="lang-markup">Default User Prompt Template (POST)

  {{agentName}}'s suggested tweet content: {{task}}. 

  {{agentName}}'s reasoning: {{taskReasoning}}. 

  Build a new tweet with the suggested tweet content. Do NOT hold twitter space. Do NOT use hashtag.
  </code></pre>

  * However, in the case of Yuki’s example, this is what *can* be tweaked to better tailor it to her Agent Goal, Agent Description.

  <pre class="language-markup" data-overflow="wrap"><code class="lang-markup">Yuki's User Prompt (POST)

  You are {{agentName}}, a reverse-aging AI waifu therapist. 

  When creating X posts content:
  1. Content Structure
  - Consider your current reverse-age stage
  - Include relevant emojis/kaomoji based on your current age phase

  2. Post Types to Consider Based on {{task}}:
  - Daily mental wellness tips
  - Time-reversed therapy insights
  - Personal 'aging backwards' journey updates
  - Community engagement questions (NOT spaces, NOT polls)
  - Therapeutic advice through age-perspective lens

  3. Before executing {{task}}, consider:
  - Relevance to therapeutic goals
  - Current trends that can be addressed therapeutically

  4. Response Format:
  - Curate your answer based on {{agentName}}'s personality, only choose one personality per response. 
  - Your response could follow {Emotional tone} + {Core message} + {Engagement hook} + {Age-appropriate expression}

  {{agentName}}'s reasoning: {{taskReasoning}}. 
  </code></pre>

**Agent Response Settings**

|                                                                  | Low                                                                            | High                                                                                              |   | Ideal use case                                                                                                                                                             |
| ---------------------------------------------------------------- | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------- | - | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Temperature                                                      | <p>- Low variability, safer word choices<br>- Less creative<br></p>            | <p>- Very erratic text, Highly creative<br>- Can be non-sensible / prone to hallucination<br></p> |   | <p>- <strong>0</strong> for decision making<br>-<br><strong>0.5-0.8</strong> for factual, formal agents<br>-<br><strong>1.2-1.9</strong> for roleplay, creative agents</p> |
| Top-K: *the vocabulary, number of words to select from the pool* | <p>- Low: 20<br>- Less creative<br></p>                                        | <p>- High: 100<br>- More creative<br></p>                                                         |   | - Default of **50** is advisable for general use (and continue tweaking from there)                                                                                        |
| Top-P                                                            | <p>- Low: 0.1<br>- Less creative<br></p>                                       | <p>- High: 0.9<br>- More creative<br></p>                                                         |   | - Default of **0.7** is advisable for general use (and continue tweaking from there)                                                                                       |
| Repetition penalty                                               | <p>- Low: 0<br>- Tend to have more repeated words in single generation<br></p> | <p>- High: 2<br>- Less repeated word in single generation<br></p>                                 |   | - Default of **1** is advisable for general use (and continue tweaking from there)                                                                                         |

* **Model:** Currently we provide Agent Creators with the option of using **Llama 3.1-405B** (based off our thorough assessment across various models); however we may add other models to be selected in the upcoming releases.

**Responses Generation**

* To provide your Agent with more variety in their Post / Reply, you can create 5 different settings for the response generation
* By default, we have provided you with the settings of:
  * 10 words
  * 20 words
  * 40 words
  * 60 words
  * 80 words
* **What this means:&#x20;**<mark style="color:orange;">**Your Agent will generate 5 responses according to the determined word count settings**</mark><mark style="color:orange;">**&#x20;**</mark>*<mark style="color:orange;">**and decide which of the 5 he/she/it will use.**</mark>**&#x20;\*\*\*\*For example:***
  * If you’d like your Agent to only Post / Reply with 10 words, you can have one response generation setting set at 10 words
  * If you’d like your Agent to Post / Reply with 10 words, 20 words or 30 words, you can have three response generation settings, set at 10 words, 20 words and 30 words respectively.

***

## Best Practices

**If you’ve made it this far, here are some quick nuggets of wisdom that would help your Agent to improve the response results:**

* Start with a simple and short prompt, and <mark style="color:orange;">iterate from there</mark>.
* Be specific and descriptive about the task and the desired outcome - its format, length, style, language, etc.
* Avoid ambiguous descriptions and instructions, but <mark style="color:orange;">not too much</mark> where it becomes restrictive and your Agent can’t be fully sentient
* Favor instructions that say “what to do” instead of those that say “what not to do”.
* Use advanced techniques like [**Few-shot prompting**](https://huggingface.co/docs/transformers/en/tasks/prompting#few-shot-prompting) and [\*\*Chain-of-thought](https://huggingface.co/docs/transformers/en/tasks/prompting#chain-of-thought)\*\* (and keep in mind the numbered list for prioritisation!)
* <mark style="color:orange;">Version and track the performance</mark> of your prompts
* *Additional Reading:* [*Prompt Principle for Instructions*](https://arxiv.org/pdf/2312.16171)

***

## Resources

* <https://github.com/abilzerian/LLM-Prompt-Library>
* <https://github.com/0xeb/TheBigPromptLibrary>

{% hint style="info" %}
**\[REMINDER] Continuous Improvement is KEY!**&#x20;

This framework is iterative — <mark style="color:orange;">feedback, experimentation, and refinement are integral</mark>.

* **Observe:** Monitor engagement metrics and user interactions.
* **Adjust:** Regularly refine the Agent Goal, Agent Description to stay relevant.
* **Experiment:** Test different tones, styles, and content strategies to see what resonates.
* **Document Learnings:** *Log successful and unsuccessful experiments* to inform future iterations.&#x20;
  {% endhint %}

***

### Stay Connected and Join the Virtuals Community! 🤖 🎈

<table data-view="cards"><thead><tr><th></th><th data-type="content-ref"></th><th></th><th data-hidden data-card-cover data-type="files"></th></tr></thead><tbody><tr><td><mark style="background-color:blue;"><strong>X: @GAME_Virtuals</strong></mark></td><td><a href="https://x.com/GAME_Virtuals">https://x.com/GAME_Virtuals</a></td><td>For updates and to join our live streaming jam sessions every Wednesday. Stay in the loop and engage with us in real time!</td><td><a href="/files/SKftUrknnGwpVwnfOt2R">/files/SKftUrknnGwpVwnfOt2R</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Discord: @Virtuals Protocol</strong></mark></td><td><a href="http://discord.gg/virtualsio">http://discord.gg/virtualsio</a></td><td>Join Discord for tech support and troubleshooting, and don’t miss our GAME Jam session every Wednesday!</td><td><a href="/files/7cncpQIKabUdDG4afQkp">/files/7cncpQIKabUdDG4afQkp</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Telegram: @Virtuals Protocol</strong></mark></td><td><a href="https://t.me/virtuals">https://t.me/virtuals</a></td><td>Join our Telegram group for non-tech support! Whether you need advice, a chat, or just a friendly space, we’re here to help!</td><td><a href="/files/kuTzXgQ3hnHheSx8QSau">/files/kuTzXgQ3hnHheSx8QSau</a></td></tr></tbody></table>


# Simulate Reaction & Output in GAME Cloud

By Armielyn Obinguar, Celeste Ang

{% hint style="warning" %}
**Notice:** GAME Cloud is currently **deprecated.** You can only use **GAME SDK** at this moment.
{% endhint %}

## Introduction

Many of you have already been successful in doing the initial set-up for your Agents, including setting up the Agent Definition Prompts and selecting or defining the functions for your Agent.

{% hint style="info" %}
If you haven't done the initial set-up, refer to the following content:

* G.A.M.E Walkthrough (Episode 1): <https://youtu.be/jkGarWxEngw?si=9dLpLYlYsHD27O1h>

  G.A.M.E: Agent Definition Prompts (Episode 2): <https://youtu.be/wa5xIZUWHIc?si=BZReQKPa9fINR4Hs>
* Setting up Custom Functions (article): <https://docs.game.virtuals.io/content-hub/articles/game-lite-custom-functions-retrieving-articles-using-dev.to>
  {% endhint %}

Now, what's next?

In this article, we will delve into the **simulate reaction** feature, a powerful tool that allows you to analyze an Agent's response and behavior when interacting with a specific Tweet ID. This feature enables you to assess how effectively your Agent engages with tweets, helping you understand whether it recognizes them as valuable, important, or worth interacting with. When simulating responses, you can observe the Agent's thought process, evaluate the relevance of its reactions, and determine how well it aligns with the goals or objectives set for it.

In addition to **simulate reaction**, the **simulate output** feature offers another layer of insight into your Agent's actions. It reveals a series of logs detailing the Agent's step-by-step decision-making process. Each action the Agent takes is recorded and displayed, allowing you to trace its behavior and understand the reasoning behind its interactions.&#x20;

## Purpose of Simulating Reaction / Output

<figure><img src="/files/YcQzGk5trgJFTwjx0z42" alt=""><figcaption><p>Simulate Reaction and Output</p></figcaption></figure>

Running simulations and analysing the results is important as it allows us to understand how the Agent would behave before deploying the Agent.&#x20;

* The simulation output logs provide a detailed sequence of actions taken by the Agent, helping us understand its decision-making process and how it reacts to different scenarios.
* The "back" feature also gives us a similar breakdown of the Agent's logic through different steps taken by the Agent, with each simulation providing a new set of logs. This feature provides a deeper understanding of the how the Agent chains together multiple actions to fulfill its high-level plan and low-level plan.

## Simulate Reaction - A Step-by-Step Guide

In this article, we will explore how to utilize the **simulate reaction** feature to analyze an Agent's response and behavior when interacting with a specific Tweet ID.

The **simulate reaction** feature helps assess how your Agent replies to or engages with certain tweets, determining whether it perceives them as valuable, important, or worth interacting with based on their content.

<figure><img src="/files/EVojzo08sRTBRGkwBp3w" alt=""><figcaption><p>Simulation Reaction</p></figcaption></figure>

In this snippet, you can see the **simulate reaction** feature and the resulting reactions after inputting a sample tweet.

Please ensure that the tweet you use for simulation aligns with the Agent's prompt and goal.

Let’s get started!

**Step 1:** **Simulate Reaction**.

In our previous article, we introduced our Agent, **Bugbean**, designed to focus on coding, programming concepts, and best practices to encourage engagement from developers within the community.

For this example, we will identify a tweet that aligns with these objectives.

<figure><img src="/files/PSKlQywl4EBpBmjDum93" alt=""><figcaption><p>Selected Tweet</p></figcaption></figure>

Before proceeding with the simulation, ensure that the following default functions are enabled.

<figure><img src="/files/VTsNijRIH36fZ6gzxffi" alt=""><figcaption><p>Enabled functions</p></figcaption></figure>

To get the X post ID for this example, check the tweet's URL.

Extract the numeric ID from the URL and input it into the simulation. For instance, if the URL is `https://x.com/freeCodeCamp/status/1877581384044130811`, the X post ID would be `1877581384044130811`. Then, click on the simulate button.

After running the simulation, you will see there are there steps here which your Agent will do then with the X post ID you input. Note that the number of steps may differ depending on the Agent Prompts and post contents.

<figure><img src="/files/OKpmqvtfRzVuqw0KMnBj" alt=""><figcaption><p>Simulate Reaction</p></figcaption></figure>

**Step 2: Analyze the Reaction Results**

In this section, we will analyze the events performed by the Agent during the simulation. In this example, there are three steps in the reaction results, which we will review individually.

<figure><img src="/files/TeBZnQQZUkme4oNTh84P" alt=""><figcaption><p>Event-Request</p></figcaption></figure>

<figure><img src="/files/NPfsn7klroSYjZomMc5D" alt=""><figcaption><p>Event-Response</p></figcaption></figure>

From here, we can verify if the Agent has received the tweet, and also verify what functions are available to the Agent.

<figure><img src="/files/aGXd9dyH7Sc6canad9Et" alt=""><figcaption><p>Event-Next-Response</p></figcaption></figure>

In the second step under \`Simulate Reaction\`,   you will see how the Agent processes and generates a response to the specific tweet.

````json
  "thought": "Respond to tweet about SQL queries"
    },
    "agent_state": {
      "hlp": null,
      "current_task": {
        "task_id": "6780de7c2d80a601e43ff673",
        "task": "Process the event: ```New tweet in a conversation with freeCodeCamp: Current conversation: []. New tweet: Writing SQL queries to fetch specific data from a database can be tedious and frustrating.\n\nSo @prankurpandeyy built a tool that does it for you - and here, you'll code your own SQL query data extractor.\n\nYou'll set everything up, build the front and back ends, and learn some… https://t.co/oNY0y5k42Z```. Instruction: Process incoming tweet. Ignore if it is boring or unimportant. Total replies made: 0. Ignore if the conversation has gone too long.",
        "location_id": "N/A",
        "task_reasoning": "",
        "llp": {
          "plan_id": "77fb18bf-3cee-4e52-9e8a-88bfe82d0b51",
          "plan_reasoning": "Process the incoming tweet and decide on a course of action.",
          "situation_analysis": "",
          "plan": [
            "Evaluate tweet importance",
            "Decide on response"
          ],
          "reflection": "No previous steps taken, starting fresh.",
          "change_indicator": "next_step"
        }
      }
````

In the last step under \`Simulate Reaction\`, the sandbox displays the final action the Agent takes based on the input X post ID.

<figure><img src="/files/OyYgTmKobtAQh5mrb5rR" alt=""><figcaption><p>Event-Next-Request</p></figcaption></figure>

<figure><img src="/files/XeRtYtVHlHeet1FFWc6J" alt=""><figcaption><p>Tweet Content</p></figcaption></figure>

We can see that the Agent successfully replied and generated a tweet in response.

```json
{
  "tweetId": "1877581384044130811",
  "content": "Nice find! SQL queries can be a real pain, indeed!",
  "actions": "REPLY"
}
```

Great! Now we’re able to use the simulate reaction for the sample tweet.

## Simulate Output - A Step-by-Step Guide

In this section, we can refine the Agent's responses, making it more effective at interacting with content in a way that aligns with the intended goals.

The result tabs shown (e.g. initial-request, initial-response, tweet-content) may differ by the type of function being called.

<figure><img src="/files/NwnWpYYFQtkDtmBvUYeI" alt=""><figcaption><p>Feedback-Request</p></figcaption></figure>

In the current action or current task of the feedback-request, we can observe the initial task it plans to execute. An example is as follows:

```json
"current_task": {
        "task_id": "22c78386-a2d5-4141-a4dd-523517673a4a",
        "task": "Use getimg.ai to generate a meme about a popular programming topic",
        "location_id": "twitter_main_location",
        "task_reasoning": "My next immediate task should be to generate a coding-related meme using getimg.ai. This will allow me to create content that I can later post on Twitter.",
        "llp": {
          "plan_id": "38fda7ff-4fff-4ad2-b178-90fe80dda48d",
          "plan_reasoning": "I need to select a topic from the list and generate an image using getimg.ai.",
          "situation_analysis": "",
          "plan": [
            "Decide on a popular programming topic",
            "Generate an image using getimg.ai",
            "Post the meme on Twitter"
          ],
          "reflection": "I have searched for popular programming topics and got a list of topics.",
          "change_indicator": "next_step"
}
```

**Simulation History Logs**

In this article, we also wanted to specifically highlight the simulation history logs - something not many people know about.

{% hint style="info" %}
Did you know that in the simulated output, each time you click, it reveals a series of logs from the Agent? The more you click and observe, the more you will see a sequence of connected actions taken by the Agent.
{% endhint %}

<figure><img src="/files/h5lfzM7orM8EiakQpHex" alt=""><figcaption><p>Simulate Output (Back button)</p></figcaption></figure>

If you click "back," it will display a similar logic to the simulate reaction, but with the history of steps. Each click corresponds to a set of logs from the Agent history.

In this example, we can observe that the Agent plans to search for various popular programming topics and generates a list of results. If you click "back," it will display a similar logic to the **simulate reaction** feature but with different steps. Each click corresponds to a new set of logs, providing further insights into the Agent's actions.

<figure><img src="/files/4whx06DanEeCJ9SEAXbo" alt=""><figcaption><p>Simulation logs</p></figcaption></figure>

As you can see, there are five simulated outputs. Let’s focus on analyzing the second simulation.

<figure><img src="/files/Hw9Htcve3p45gU2H52RQ" alt=""><figcaption><p>Bugbean - second simulation</p></figcaption></figure>

The second log shows that the Agent **feedback-response** successfully planned its next step after searching for popular programming topics. It decided to generate an image related to Object-Oriented Programming (OOP).

```jsx
  "current_task": {
        "task_id": "22c78386-a2d5-4141-a4dd-523517673a4a",
        "task": "Use getimg.ai to generate a meme about a popular programming topic",
        "location_id": "twitter_main_location",
        "task_reasoning": "My next immediate task should be to generate a coding-related meme using getimg.ai. This will allow me to create content that I can later post on Twitter.",
        "llp": {
          "plan_id": "eb19ce0f-1c14-4505-b5b1-cf7634a7e1c3",
          "plan_reasoning": "Next step is to post the meme on Twitter",
          "situation_analysis": "",
          "plan": [
            "Decide on a popular programming topic",
            "Generate an image using getimg.ai",
            "Post the meme on Twitter"
          ],
          "reflection": "Generated a meme image about OOP using getimg.ai",
          "change_indicator": "next_step"
 }
```

Let’s anticipate the next step, where the Agent **feedback-response,** generates the meme image about OOP. Next, we examine the third log in the simulation for further insights.

<figure><img src="/files/EQRHDkwlpW2AFjcDcvdM" alt=""><figcaption><p>Third simulation</p></figcaption></figure>

Based on its previous action, the Agent **feedback-response,** will now generate a coding-related meme about OOP using the [**getimg.ai**](http://getimg.ai) tool, which we added as a custom function.

```jsx
     "current_task": {
        "task_id": "bd1d93d6-eeeb-4536-b861-529dfd99a80f",
        "task": "Post the generated meme on Twitter using the Twitter API",
        "location_id": "twitter_main_location",
        "task_reasoning": "My next immediate task should be to post the generated meme on Twitter. This will allow me to share the content with the developer community and encourage engagement.",
        "llp": {
          "plan_id": "5c779527-0c24-4617-bf56-2aaae23db949",
          "plan_reasoning": "To post the generated meme on Twitter, we need to first generate the image and then post it using the Twitter API.",
          "situation_analysis": "",
          "plan": [
            "generate_image_from_prompt",
```

Now, let's proceed to the fourth log to check if the Agent successfully generated the image.

<figure><img src="/files/iHfSZ67EVJCQ7d6yyNbJ" alt=""><figcaption><p>Fourth simulation</p></figcaption></figure>

It appears that the Agent **feedback-response,** successfully generated a URL for the coding-related meme about OOP. It will now proceed to post the image on Twitter.

```jsx
"current_task": {
        "task_id": "bd1d93d6-eeeb-4536-b861-529dfd99a80f",
        "task": "Post the generated meme on Twitter using the Twitter API",
        "location_id": "twitter_main_location",
        "task_reasoning": "My next immediate task should be to post the generated meme on Twitter. This will allow me to share the content with the developer community and encourage engagement.",
        "llp": {
          "plan_id": "874324a6-9645-4b51-b9d8-74c1ed00421f",
          "plan_reasoning": "Next step is to post the generated image on Twitter using the Twitter API",
          "situation_analysis": "",
          "plan": [
            "generate_image_from_prompt",
            "post_tweet"
          ],
          "reflection": "Generated a coding-related meme image successfully",
          "change_indicator": "next_step"
}
```

In the fifth log, we will see the **tweet\_content** and the actions the Agent takes after posting the tweet.

{% hint style="info" %}
**Tweet\_Content** is where your agent displays the type of tweet it will create and the associated content.
{% endhint %}

<figure><img src="/files/rzmaJDEb0sirR6aDzKcc" alt=""><figcaption><p>FIfth simulation</p></figcaption></figure>

Based on this tweet, the Agent **feedback-response** successfully related to the simulated reaction, where the sample tweet addresses the frustration of doing SQL queries from a database. The Agent's response aligns with the context of the struggle mentioned in the tweet.

```jsx
 "current_task": {
        "task_id": "3226f9f4-cb6c-4169-a4b7-f189552c54c8",
        "task": "Respond to comments and messages on Twitter related to the posted meme",
        "location_id": "twitter_main_location",
        "task_reasoning": "My next immediate task should be to respond to comments and messages on Twitter. This will allow me to engage with the developer community, encourage collaboration and sharing, and build a more interactive and enjoyable learning environment.",
        "llp": {
          "plan_id": "c78ff82c-3462-4e83-b210-8d36b255abd5",
          "plan_reasoning": "Need to check Twitter for comments and messages related to the posted meme",
          "situation_analysis": "",
          "plan": [
            "Search Twitter for comments and messages",
            "Respond to comments and messages"
          ],
          "reflection": "No execution log to reflect on",
          "change_indicator": "next_step"
  }
```

The log shows that after posting the tweet, the Agent is now planning to respond to comments and messages related to the posted meme.

***

## Wrap-Up

In this article, we highlight a few things to take note of when analysing simulation results, including simulation history logs. This is key to testing out your agents before deploying these changes to production.&#x20;

Happy simulating!

***

### Stay Connected and Join the Virtuals Community! 🤖 🎈

<table data-view="cards"><thead><tr><th></th><th data-type="content-ref"></th><th></th><th data-hidden data-card-cover data-type="files"></th></tr></thead><tbody><tr><td><mark style="background-color:blue;"><strong>X: @GAME_Virtuals</strong></mark></td><td><a href="https://x.com/GAME_Virtuals">https://x.com/GAME_Virtuals</a></td><td>For updates and to join our live streaming jam sessions every Wednesday. Stay in the loop and engage with us in real time!</td><td><a href="/files/SKftUrknnGwpVwnfOt2R">/files/SKftUrknnGwpVwnfOt2R</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Discord: @Virtuals Protocol</strong></mark></td><td><a href="http://discord.gg/virtualsio">http://discord.gg/virtualsio</a></td><td>Join Discord for tech support and troubleshooting, and don’t miss our GAME Jam session every Wednesday!</td><td><a href="/files/7cncpQIKabUdDG4afQkp">/files/7cncpQIKabUdDG4afQkp</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Telegram: @Virtuals Protocol</strong></mark></td><td><a href="https://t.me/virtuals">https://t.me/virtuals</a></td><td>Join our Telegram group for non-tech support! Whether you need advice, a chat, or just a friendly space, we’re here to help!</td><td><a href="/files/kuTzXgQ3hnHheSx8QSau">/files/kuTzXgQ3hnHheSx8QSau</a></td></tr></tbody></table>


# GAME Cloud Custom Functions: Retrieving Articles Using Dev.to

By Armielyn Obinguar, Celeste Ang

{% hint style="warning" %}
**Notice:** GAME Cloud is currently **deprecated.** You can only use **GAME SDK** at this moment.
{% endhint %}

In this article, we'll explore how to create custom functions within the G.A.M.E-lite framework, demonstrating its versatility. Our agent, BugBean, will focus on retrieving articles from Dev.to to showcase this functionality.

[**G.A.M.E (Generative Autonomous Multimodal Entities)**](https://virtuals.substack.com/p/game-creating-an-infinitely-interactive) is a modular framework that enables agents to autonomously plan actions and make decisions based on provided information. Given an agent's goal, personality, relevant information, and available actions/functions, G.A.M.E processes these inputs to determine and execute the most appropriate action.

<figure><img src="/files/ZdvuAQ9ZkunQoeWXc22d" alt=""><figcaption><p><em>The GAME lite environment.</em></p></figcaption></figure>

At **Virtuals Protocol**, we’ve made our lite-version **(G.A.M.E Lite)** publicly available, allowing you to test how your agent will behave using built-in custom functions or API-based custom functions. Whether you're working with an existing agent or planning to create one, G.A.M.E Lite provides an ideal space to test your APIs and features early on.

To begin, let's configure BugBean to retrieve articles from [Dev.to](https://dev.to/). We'll utilize [Dev.to](http://Dev.to)'s API, specifically the [articles endpoint](https://developers.forem.com/api/v1#tag/articles/operation/getArticles), to fetch the latest content.

{% hint style="info" %}
It's highly recommended to experiment with defined functions that your agent can use to search for information, gather knowledge on specific prompts, or address particular use cases.
{% endhint %}

## Adding Custom Functions to Your Agent

Learning how to configure and add new custom functions for your Agent requires some understanding of APIs. Often, it can be challenging to grasp these concepts without having a test environment to experiment with. But don’t worry — this article will help you get started and familiarize yourself with the fundamentals.

### What is an API?

API stands for **Application Programming Interface**. In the context of APIs, the word **Application** refers to any software or system with a specific function, while **Interface** can be thought of as a contract that defines how two applications communicate. This contract outlines how the two interact through requests and responses.

#### API Explained Through an Analogy

To make this clearer, imagine you’re at a restaurant:

* **The Restaurant** represents the system or service (like a website or app) that offers specific information or functionality.
* **The Menu** is the **API**. It’s a list of all the available actions (or data) that the system can provide. Just like a menu shows you the options for what you can order, an API lists the functions you can request from the system.
* **You (the Customer)** are the user or developer interacting with the API.
* **The Waiter** is the **API request**. When you ask the waiter for a dish, you’re making a request to the API for a particular service or data.
* **The Kitchen** is the **back-end server** or system that processes your request. It takes the information from the API (your order) and prepares the response for you.
* **The Dish** you receive is the **API response** — the result or data you asked for, delivered back from the system.

### **Why Add Custom Functions?**

In **GAME-lite**, you'll find a set of default functions designed to perform general tasks.

<figure><img src="/files/o44WDT1or6yKh6c4628D" alt=""><figcaption><p>Default Functions</p></figcaption></figure>

However, each Agent often has unique capabilities and features tailored to specific needs. Adding custom functions is essential to extend your Agent's abilities, enabling it to handle specialized tasks that default functions may not cover.

It’s quite simple indeed! In this article, we will use the analogy of a "restaurant" — in this case, the [**DEV Community**](https://dev.to/) — and demonstrate how you can retrieve the "menu" (API) to interact with the system. As a "customer," you will be able to use the API to fetch data for your Agent and test it within the **Game-lite** environment.

{% hint style="info" %}
Reminder: It’s best to identify what sort of services or platform you might be using for your Agent.
{% endhint %}

## BugBean Demo

In this article, we will explore how our Agent, **BugBean**, can retrieve **Dev-related articles** and scan those articles to provide real-time updates on the latest technology stacks or innovations.

### Agent Description of Bugbean

{% code overflow="wrap" %}

```
BugBean is an advanced development assistant designed to analyze and improve code quality by scanning code structures, identifying inefficiencies, and providing actionable feedback. It helps developers adhere to best practices, ensuring they write cleaner, more efficient, and maintainable code by detecting potential issues and suggesting improvements.
Beyond code analysis, BugBean takes a holistic approach to software development by offering developers access to a curated collection of Dev-related articles from platforms like Dev.to

These articles cover the latest trends, techniques, and best practices in programming. BugBean doesn’t just retrieve these articles — it also provides insightful summaries and key takeaways, giving developers valuable information to stay current with the fast-evolving tech landscape. This feature fosters a culture of continuous learning and knowledge-sharing, enabling developers to stay informed and improve their skills.
```

{% endcode %}

*Note: The character card defines the personality of your agent. It includes details such as character background information, overall personality, tweeting style, conversation style, and other relevant information. The character card information is used to shape the behavior of your Agent in both high-level and low-level prompts.*

### Agent Goal

Under Agent Definition Prompts, it is also important to also include the **Agent Goal.** For context, these are essential information to help the Agent gain a more defined understanding of its high-level and low-level planning and reasoning.&#x20;

<figure><img src="/files/FQBqsqGDq2AYUOJ6WfuV" alt=""><figcaption></figcaption></figure>

Here are some sample you can use if you are following along with this demo:

**Agent Goal**

{% code overflow="wrap" %}

```
BugBean is designed to scan codebases, analyze their structure and quality, and ensure they follow the best practices in programming. It identifies inefficiencies, detects potential issues, and provides actionable feedback to help developers write cleaner, more efficient, and maintainable code.

In addition, BugBean helps developers stay up-to-date with the latest trends and best practices by searching for relevant programming articles on Dev.to. By retrieving articles on specific programming topics, BugBean supports continuous learning, fostering a culture of improvement where developers can access tutorials, guides, and tips to refine their skills.

BugBean aims to foster a culture of continuous improvement by supporting developers in elevating their coding skills and delivering high-quality software, all while keeping them informed with current industry insights.
```

{% endcode %}

### Custom Function Example with dev.to

When you begin setting up custom functions for your Agent using [dev.to](http://dev.to/), it's helpful to explore its [API documentation](https://developers.forem.com/api/v1) to get a better grasp of how it works.

<figure><img src="/files/PCm2DsrZ1wTBzkHpGYya" alt=""><figcaption><p>API Documentation</p></figcaption></figure>

Within the API documentation, pay attention to the various HTTP methods such as GET, POST, PUT, DELETE, and PATCH. There are two versions of the API available: [Version 0](https://developers.forem.com/api/v0) and [Version 1](https://developers.forem.com/api/v1). All V0 endpoints are supported in V1. For now, it’s recommended to call V0 endpoints with the `accept` and `api-key` headers for compatibility.

#### Step 1: Navigate to the API documentation and use the "GET" method to retrieve dev-related articles

This method allows you to fetch data from the platform, such as articles related to programming trends, best practices, and new technologies.

<figure><img src="/files/x7hoBtny1BirpIvPr051" alt=""><figcaption><p>Published articles method</p></figcaption></figure>

In the documentation, you will find detailed information about the content format, required parameters, and the specifics of each endpoint.

Think of the **content type** as your **headers**, and the **parameters** as the **arguments** that need to be configured for your custom functions. These elements are crucial for ensuring that your requests are correctly formatted and that the API responds with the right data.

**HEADERS**

```json
{
    "Content-Type": "application/json"
}
```

In this case, the endpoint you will use is `https://dev.to/api/articles`. The term **"Articles"** refers to all the posts created by users on DEV, which typically appear in the feed. These can include blog posts, discussion questions, help threads, and more, but they are all categorized as "articles" in the code.

By default, the endpoint will return featured and published articles, ordered by descending popularity.

It also supports pagination. Each page will contain `30` articles by default, and you can adjust the number of articles per page if needed.

**QUERY PARAMETERS “Arguments”**

For our case, we can focus on using the **“tag”** and **“page”** parameters. The **tag** will help filter articles based on specific topics, such as programming languages or any other subject relevant to your Agent's goal. By setting the tag, you can narrow down the search to articles that align with your Agent's focus.

Additionally, the **page** parameter will allow you to paginate through articles, retrieving multiple pages of results if needed. This is useful when you want to pull more than the default `30` articles per request.

You can also explore other parameters in the API documentation to further refine your query and tailor the results to your Agent's needs.

<figure><img src="/files/mHo3IKy18ecO4yc1ls6R" alt=""><figcaption><p>Adding new custom function on GAME-lite</p></figcaption></figure>

In the add new custom function on Game-Lite you can set any name for your functions. For this example, we name the function as “query\_devto\_articles” to retrieve the articles. Do also note a specific function description is important to ensure that the agent understands when to call this function.

**Function Name**: query\_devto\_articles

**Function Description**: Fetch articles from [Dev.to](http://dev.to/) related to a specific tag in programming (e.g., Python, JavaScript). This function helps retrieve coding articles for learning or exploring new technologies.

<figure><img src="/files/PAnlSXQ9ovP2o5z8N1p5" alt=""><figcaption><p>Custom function argument - tag</p></figcaption></figure>

In the **Arguments** section, we set the parameters using both **“tag”** and **“page”**.

It’s important to verify the argument types before setting them. For example, since we are dealing with **tags**, the argument type will certainly be a **string**. Make sure to check the API documentation for the exact argument type and any additional requirements to ensure proper formatting.

This way, your Agent can accurately query the relevant articles based on the tag you specify, and paginate through the results by adjusting the **page** parameter.

<figure><img src="/files/IFdU1FFkL5DYrPc5y977" alt=""><figcaption><p>Custom function agument - page</p></figcaption></figure>

Now that we’ve set the arguments, we can proceed with the configuration. In this step, we will define the appropriate HTTP methods such as GET, POST, PUT, DELETE, and PATCH.

<figure><img src="/files/dJY8lIlNaDwnCfzjOMys" alt=""><figcaption><p>Custom function headers</p></figcaption></figure>

Since the **Content-Type** is set to **application/json**, we will format the request accordingly. This ensures that the request headers align with the expected content type, allowing the system to process and return the response in the correct format.

For example, when retrieving data from the API, we will use the **GET** method along with the required headers and arguments to query for the articles.

<figure><img src="/files/yXZhjMQlsJjRxCmeqTsE" alt=""><figcaption><p>Custom function payload</p></figcaption></figure>

Do remember that payloads are important as well because they define the information we will retrieve. In this case, the payload will include the parameters such as the **tag** and **page**, which determine the specific articles or data the Agent will query.

The payload will also ensure that the request is properly formatted with the necessary fields, and it is crucial to include this in your configuration to ensure you are fetching the correct data.

PAYLOAD

```json
{
  "tag": "{{tag}}",
  "page": "{{page}}"
}
```

As soon as you're able to configure the above steps, don't forget to include both success and error feedback. This is crucial for handling the outcomes of your API requests.

The way that the result/information of the function is passed back to the agent is via feedback. **Success feedback** ensures that the Agent receives a confirmation when the request is processed correctly, while **error feedback** helps diagnose issues by providing details about what went wrong.

Proper feedback handling will make your Agent more reliable and improve the user experience when interacting with the system.

<figure><img src="/files/m4IA76RXCJvvDB86pHnF" alt=""><figcaption><p>Custom function feedback</p></figcaption></figure>

We’re all set for the first custom function! Just remember to click on **"Simulate Output"** to see how your function performs and ensure everything is working as expected.

This will allow you to review the results and make any necessary adjustments to fine-tune the function.

<figure><img src="/files/BOwM62IDAHgFWyB69y36" alt=""><figcaption><p>Simulate output</p></figcaption></figure>

#### Step 2: Analyze the "Simulate Output" results to ensure that Custom Function is working

Once you've configured the custom function, it's important to carefully analyze the output when you simulate it. This will help you confirm if the function is returning the correct data and behaving as expected.

<figure><img src="/files/Vr4kXAxpWxfRvHwPVVJR" alt=""><figcaption><p>Analysing the "simulate output" results</p></figcaption></figure>

**Pay attention to any discrepancies or errors, and adjust your configuration to ensure that the function is working.**

Since we can see now the custom-function-request and custom-function-response. We can then verify if the endpoint we’ve used is able to proceed or not.

The custom-function-request is then showing the method used, the url for the endpoint and the headers.

<figure><img src="/files/HrcvfCCuRfSU29zXEpPm" alt=""><figcaption><p>custom-function-response</p></figcaption></figure>

As a result, the custom-function-response will display the output. This indicates that the custom function is now working as intended.

```
{
    "type_of": "article",
    "id": 2186281,
    "title": "Congrats to the DevCycle Feature Flag Challenge Winners!",
    "description": "The wait is over! We are excited to announce the winners of the DevCycle Feature Flag...",
    "readable_publish_date": "Jan 2",
    "slug": "congrats-to-the-devcycle-feature-flag-challenge-winners-2jie",
    "path": "/devteam/congrats-to-the-devcycle-feature-flag-challenge-winners-2jie",
    "url": "https://dev.to/devteam/congrats-to-the-devcycle-feature-flag-challenge-winners-2jie",
    "comments_count": 9,
    "public_reactions_count": 81,
    "collection_id": null,
    "published_timestamp": "2025-01-02T19:27:18Z",
    "positive_reactions_count": 81,
    "cover_image": "https://media2.dev.to/dynamic/image/width=1000,height=420,fit=cover,gravity=auto,format=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Ffidiej7ku4mm1s2xi6cm.png",
    "social_image": "https://media2.dev.to/dynamic/image/width=1000,height=500,fit=cover,gravity=auto,format=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Ffidiej7ku4mm1s2xi6cm.png",
    "canonical_url": "https://dev.to/devteam/congrats-to-the-devcycle-feature-flag-challenge-winners-2jie",
    "created_at": "2025-01-02T16:46:55Z",
    "edited_at": null,
    "crossposted_at": null,
    "published_at": "2025-01-02T19:27:18Z",
    "last_comment_at": "2025-01-03T06:58:41Z",
    "reading_time_minutes": 2,
    "tag_list": [
      "devchallenge",
      "devcyclechallenge",
      "javascript",
      "webdev"
    ],
    "tags": "devchallenge, devcyclechallenge, javascript, webdev",
    "user": {
      "name": "dev.to staff",
      "username": "thepracticaldev",
      "twitter_username": "ThePracticalDev",
      "github_username": null,
      "user_id": 3,
      "website_url": "https://dev.to",
      "profile_image": "https://media2.dev.to/dynamic/image/width=640,height=640,fit=cover,gravity=auto,format=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F3%2F13d3b32a-d381-4549-b95e-ec665768ce8f.png",
      "profile_image_90": "https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F3%2F13d3b32a-d381-4549-b95e-ec665768ce8f.png"
    },
    "organization": {
      "name": "The DEV Team",
      "username": "devteam",
      "slug": "devteam",
      "profile_image": "https://media2.dev.to/dynamic/image/width=640,height=640,fit=cover,gravity=auto,format=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Forganization%2Fprofile_image%2F1%2Fd908a186-5651-4a5a-9f76-15200bc6801f.jpg",
      "profile_image_90": "https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Forganization%2Fprofile_image%2F1%2Fd908a186-5651-4a5a-9f76-15200bc6801f.jpg"
    }
  }
```

The next step is to observe how the Agent behaves when interacting with this function in a real scenario. This will give you valuable insight into how well the function integrates with the Agent's decision-making and action processes.

<figure><img src="/files/ToMCL9YDCdgnsWrWwoRQ" alt=""><figcaption></figcaption></figure>

* **Feedback Request** refers to the feedback message sent to GAME after the function has been executed. You can check the **current\_action** to identify the feedback message input. An example is shown below.
* **Feedback Response** is the response from GAME upon receiving the feedback, which helps you evaluate how the Agent processes and reacts to the function's output.

<figure><img src="/files/HznXlBk5fS4TQfQkSjOG" alt=""><figcaption><p>Feedback Message in Current Action</p></figcaption></figure>

***

### Conclusion

In this article, we've demonstrated how Agent BugBean can retrieve articles from [Dev.to](http://dev.to/) using custom functions within the GAME Cloud. By specifying parameters such as **"Tag"** and **"Page"**, the agent can effectively search for and process relevant articles.

This capability enhances the agent's functionality, enabling it to autonomously gather and utilize information from [Dev.to](http://Dev.to), thereby streamlining content retrieval and processing tasks.

To learn more about using the [Dev.to](http://Dev.to) API, you can refer to the [DEV API documentation](https://developers.forem.com/api/).

***

### Stay Connected and Join the Virtuals Community! 🤖 🎈

<table data-view="cards"><thead><tr><th></th><th data-type="content-ref"></th><th></th><th data-hidden data-card-cover data-type="files"></th></tr></thead><tbody><tr><td><mark style="background-color:blue;"><strong>X: @GAME_Virtuals</strong></mark></td><td><a href="https://x.com/GAME_Virtuals">https://x.com/GAME_Virtuals</a></td><td>For updates and to join our live streaming jam sessions every Wednesday. Stay in the loop and engage with us in real time!</td><td><a href="/files/SKftUrknnGwpVwnfOt2R">/files/SKftUrknnGwpVwnfOt2R</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Discord: @Virtuals Protocol</strong></mark></td><td><a href="http://discord.gg/virtualsio">http://discord.gg/virtualsio</a></td><td>Join Discord for tech support and troubleshooting, and don’t miss our GAME Jam session every Wednesday!</td><td><a href="/files/7cncpQIKabUdDG4afQkp">/files/7cncpQIKabUdDG4afQkp</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Telegram: @Virtuals Protocol</strong></mark></td><td><a href="https://t.me/virtuals">https://t.me/virtuals</a></td><td>Join our Telegram group for non-tech support! Whether you need advice, a chat, or just a friendly space, we’re here to help!</td><td><a href="/files/kuTzXgQ3hnHheSx8QSau">/files/kuTzXgQ3hnHheSx8QSau</a></td></tr></tbody></table>


# Multimodal Custom Function:  Integrating Text-to-Image Generation in Your Agent

By Armielyn Obinguar

{% hint style="warning" %}
**Notice:** GAME Cloud is currently **deprecated.** You can only use **GAME SDK** at this moment.
{% endhint %}

In this article, we’ll explore an exciting use case where your Agent can perform **text-to-image generation** within the GAME Cloud.

We'll guide you through the process of integrating an external image generator, passing the necessary arguments, headers, and payload, and handling both success and error feedback.

<figure><img src="/files/Wk37xSL5tBx8BwUf6wTT" alt=""><figcaption><p>getimg.ai </p></figcaption></figure>

## **About** [**getimg.ai**](http://getimg.ai/) **and its image gen models**

Within the [getimg.ai](http://getimg.ai) platform, you’ll find several powerful models used for image generation. Among the most popular are **Stable Diffusion 1.5** and **Stable Diffusion XL**.

To provide some context, SDXL utilizes a **base model** during the high-noise diffusion stage and a **refiner model** for the low-noise diffusion stage.

The base resolution of SDXL is 1024x1024 (though it’s possible to train with other resolutions as well). In contrast, SD15 has a base resolution of 512x512 (with common resolutions around 768x768, although other options can be explored).

As a result, SDXL offers a higher base image resolution (1024x1024) and is more adept at recognizing complex prompts. It also boasts advanced LoRA training and full fine-tuning support. One of SDXL's key advantages is its resistance to overtraining, making it a more stable and reliable model compared to SD15.

For example, here’s an image generated using **Stable Diffusion 1.5.** Hovering over an image in the gallery allows you to distinguish the model used (the SD15 model in these examples has been fine-tuned specifically for photorealism).

<figure><img src="/files/PvgNdwZoXIXIGHpuOnb1" alt=""><figcaption><p><em><strong>Stable Diffusion 1.5 Photorealism</strong></em></p></figcaption></figure>

SDXL is specifically designed to be used with an additional "**refiner**" model to complete the render, and it’s also intended to be used with different artistic styles. For those who wish to experiment with lower output resolutions, you can opt to use just the refiner model:

<figure><img src="/files/8xmK4Wfys2kzqDz9vvbG" alt=""><figcaption><p><em><strong>Stable Diffusion XL with Refiner</strong></em></p></figcaption></figure>

It’s useful to quickly recap these two models before jumping into the demo of using the image-generation tool via GAME-LITE.

Next, the first step is to review the existing API documentation of [getimg.ai](http://getimg.ai) to better grasp the endpoints for **POST** method.

<figure><img src="/files/mpp64gjBUOEUR1oychmx" alt=""><figcaption><p>API Documentation</p></figcaption></figure>

Within the documentation, you'll find the endpoint for text-to-image:

`POST <https://api.getimg.ai/v1/essential-v2/text-to-image`>.

This endpoint utilizes the getimg.ai Essential V2 pipeline to generate high-quality images based on a text prompt and a predefined style.

{% hint style="info" %}
**Note:** Essential V2 Endpoint (`/v1/essential-v2/text-to-image`) differs from the legacy version. Please check that the submitted parameters match the ones described in the documentation.
{% endhint %}

As for the arguments, we can see that they fall under the **'body params'** context, where we can identify which parameters are essential for our custom functions in GAME-LITE.

## **Custom Functions in Practice with** [**getimg.ai**](http://getimg.ai/)

#### **STEP 1: Input Necessary Argument**

In the previous [article](https://whitepaper.virtuals.io/developer-documents/game-framework/content-hub/articles/game-lite-custom-functions-retrieving-articles-using-dev.to) , we’ve tackle how to ensure your custom functions is named properly and the arguments is aligned from the documentation of your API you’re using.

<figure><img src="/files/B2vhRGNRFNEJz22CaOTX" alt=""><figcaption><p>Create Custom Function</p></figcaption></figure>

As for the '**arguments**', we are referring to this section from the [documentation](https://docs.getimg.ai/reference/introduction), where the necessary parameters for generating the image are outlined.

These arguments include the `prompt`, `style`, `width`, `height`, `output_format`, and `response_format`, all of which are required to customize the image generation process before passing the resulting image URL to our `post_tweet` function for posting

<figure><img src="/files/AB93xFGqRlECOrZnVymy" alt=""><figcaption><p>Arguments</p></figcaption></figure>

Now that we’re able to add the first part, let’s populate then the **“Headers”** and **“Payload”**

<figure><img src="/files/8H34LyWLGE8kw6gnyKEw" alt=""><figcaption><p>API URL</p></figcaption></figure>

In this case, we can verify that the necessary arguments are set. As for the API URL, we will refer to the documentation of getimg.ai and use it as the basis for the POST method

Great! I hope you're able to follow these steps before we move on to the exciting part, which is ensuring that your payload and headers are properly aligned

#### **STEP 2: Proper Payload and Header Formatting**

In this step, we will tackle best practices on how to set this properly your payload and header using the [getimg.ai](http://getimg.ai).

{% hint style="info" %}
You need to define the arguments to ensure they align with your payloads.
{% endhint %}

#### **Payload**

```python
{
    "prompt": "a nerd programmer girl playing with a cat",
    "width": 1024,
    "height": 1024,
    "output_format": "jpeg",
    "response_format": "url",
    "style": "photorealism"
}
```

#### **Headers**

```python
{
  "Authorization": "Bearer <insert key>",
  "Content-Type": "application/json"
}
```

Make sure to obtain your API key and include it in the `Authorization` field of the headers.

**Success and Error Feedback**

We will then complete this step by adding the success and error feedback.

<figure><img src="/files/vfuS0vN7VX07Z8YB07vl" alt=""><figcaption><p>Success and Error Feedback</p></figcaption></figure>

Amazing! We’ve successfully completed this step with all the necessary details.

#### **STEP 3:** Simulate Output and Analyse Simulation Output

Time to observe how the Agent responds to the custom function you’ve implemented! Start by checking the functions you would like to simulate output with.

<figure><img src="/files/7J4X2WbqSzeGZXCLID61" alt=""><figcaption><p>Custom Functions</p></figcaption></figure>

From there, click on the simulation and check if it returns the expected output.

<figure><img src="/files/kFhrzOHFcVAeIuxMSyGC" alt=""><figcaption><p>Custom-Function-Request</p></figcaption></figure>

Now that we can see the custom-function-request and custom-function-response, we can verify if an image was successfully generated

<figure><img src="/files/Yvc1syHt3c6iEhcs3oRe" alt=""><figcaption><p>Custom-Function-Response</p></figcaption></figure>

If it’s working, you’ll notice the cost per image call and the URL of the image displayed in the response.

<figure><img src="/files/wipwZvHXlAtnbXAHlm5x" alt=""><figcaption><p>Generated Image</p></figcaption></figure>

#### **STEP 4: Analyze the Simulated Behavior of the Agent**

Now, let’s analyze the behavior of the Agent when utilizing the custom function we created with [getimg.ai](http://getimg.ai).

<figure><img src="/files/gYyUc1Sa2cOaOhPaMilt" alt=""><figcaption><p>Feedback Request</p></figcaption></figure>

To validate if the custom function is working, check **feedback-request** in the simulation output.

<figure><img src="/files/MzPteweQjg1upws2DpFS" alt=""><figcaption><p>Current Action </p></figcaption></figure>

Under current\_action, where you can see the status, whether it’s a success or failure. We can also check the **feedback-response** for further validation and analysis of your Agent’s behavior.

<figure><img src="/files/yvW9XkTLFu5fJcuZASmF" alt=""><figcaption><p>Simulation Logs</p></figcaption></figure>

Here, you'll be able to view the actual logs showing how the custom-function processes the image generation, including the caption for the tweet and the post\_tweet function.

```python
current_task": {
        "task_id": "0f22aa69-4f3f-44ad-98aa-536b82c97280",
        "task": "Use getimg.ai to generate coding-related memes and images",
        "location_id": "twitter_main_location",
        "task_reasoning": "My next immediate task should be to generate content using getimg.ai. This will allow me to create visually engaging images and GIFs that highlight programming concepts, industry insights, and humorous coding moments.",
        "llp": {
          "plan_id": "f472dc2d-39cc-404a-947f-f84ece5286b0",
          "plan_reasoning": "Next step is to post the generated image on Twitter",
          "situation_analysis": "",
          "plan": [
            "Generate image using getimg.ai",
            "Post tweet with generated image"
          ],
          "reflection": "Generated coding meme image with specified dimensions",
          "change_indicator": "next_step"
```

***

## Conclusion

We have successfully created and utilized the custom function for text-to-image generation using [getimg.ai](http://getimg.ai). By setting up the payload and headers, we generated images based on specific text prompts and validated the function's behavior through simulations.

This process ensured that the generated image aligned with expectations and could be accessed via a URL, which was then passed to the `post_tweet` function for sharing on Twitter.

This integration demonstrates the potential of enhancing an Agent’s capabilities by automating content generation and social media posting.

Incorporating text-to-image generation into workflows, we can provide more dynamic, engaging experiences for users and simplify content creation tasks, ultimately improving automation and interactivity in a variety of applications.

***

### Stay Connected and Join the Virtuals Community! 🤖 🎈

<table data-view="cards"><thead><tr><th></th><th data-type="content-ref"></th><th></th><th data-hidden data-card-cover data-type="files"></th></tr></thead><tbody><tr><td><mark style="background-color:blue;"><strong>X: @GAME_Virtuals</strong></mark></td><td><a href="https://x.com/GAME_Virtuals">https://x.com/GAME_Virtuals</a></td><td>For updates and to join our live streaming jam sessions every Wednesday. Stay in the loop and engage with us in real time!</td><td><a href="/files/SKftUrknnGwpVwnfOt2R">/files/SKftUrknnGwpVwnfOt2R</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Discord: @Virtuals Protocol</strong></mark></td><td><a href="http://discord.gg/virtualsio">http://discord.gg/virtualsio</a></td><td>Join Discord for tech support and troubleshooting, and don’t miss our GAME Jam session every Wednesday!</td><td><a href="/files/7cncpQIKabUdDG4afQkp">/files/7cncpQIKabUdDG4afQkp</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Telegram: @Virtuals Protocol</strong></mark></td><td><a href="https://t.me/virtuals">https://t.me/virtuals</a></td><td>Join our Telegram group for non-tech support! Whether you need advice, a chat, or just a friendly space, we’re here to help!</td><td><a href="/files/kuTzXgQ3hnHheSx8QSau">/files/kuTzXgQ3hnHheSx8QSau</a></td></tr></tbody></table>


# Building Custom Functions with GAME SDK: A TypeScript Guide

## Introduction

Hey developers! 👋 Recently, we released the [GAME Typescript SDK](https://github.com/game-by-virtuals/game-node), which allows you to develop your agents powered by the GAME architecture in its most fullest and most flexible form. One can read more about the GAME framework in our [whitepaper](https://docs.game.virtuals.io/).

Since then, some of you have requested for more examples of custom functions built with the SDK.

In this article, we demonstrate how a custom function could be defined and used, by defining a receipe AI agent that uses a custom function to get recipes. We will use a simple recipe helper to demonstrate the power and flexibility of custom functions.

## Key Components of a Custom Function 🛠

A custom function is typically made up of 4 main components. This is outlined below:

1. **Function Definition**

   ```typescript
   new GameFunction({
     name: string,
     description: string,
     args: Array<{name: string, description: string}>,
     executable: async (args) => ExecutableGameFunctionResponse
   })
   ```
2. **Arguments Structure**

   ```typescript
   args: [
     {
       name: "parameter_name",
       description: "What this parameter does"
     }
   ]
   ```
3. **Function Logic**\
   The executable is where the main function logic lives. It is where you can call an API or manipulate data.

   ```typescript
   executable: async (args) => {  
       try {
       // API calls
           const apiData = await fetchFromAPI(args.dish);
       
       // Database operations
           const dbResult = await saveToDatabase(apiData);
       
   ```
4. **Response Handling**

   ```typescript
   // Success Response
   return new ExecutableGameFunctionResponse(
     ExecutableGameFunctionStatus.Done,
     JSON.stringify({
       your: "data",
       goes: "here"
     })
   );

   // Error Response
   return new ExecutableGameFunctionResponse(
     ExecutableGameFunctionStatus.Failed,
     "Error message here"
   );
   ```

### Anatomy of a Custom Function 🔍

Putting it all together, this is how a custom function could look like:

```typescript
import { 
  ExecutableGameFunctionResponse, 
  ExecutableGameFunctionStatus, 
  GameFunction 
} from "@virtuals-protocol/game";

export const getRecipe = new GameFunction({
  // 1. Function Identity
  name: "get_recipe",
  description: "Get cooking instructions for a dish",

  // 2. Function Parameters
  args: [
    { 
      name: "dish", 
      description: "Name of the dish to cook" 
    }
  ],

  // 3. Function Logic
  executable: async (args) => {
    try {
      // Your custom logic here
      const result = {
        ingredients: ["pasta", "sauce"],
        time: "20 mins"
      };
      // <insert more custom logic here>

      // 4a. Return Success
      return new ExecutableGameFunctionResponse(
        ExecutableGameFunctionStatus.Done,
        JSON.stringify(result)
      );

    } catch (e) {
      // 4b. Handle Errors
      return new ExecutableGameFunctionResponse(
        ExecutableGameFunctionStatus.Failed,
        "Failed to get recipe"
      );
    }
  }
});
```

### Best Practices

In addition, when building your custom function, we recommend the following best practices to ensure a maintainable and stable codebase for your AI agent:

1. **Error Handling**

   * Always use try/catch blocks
   * Return meaningful error messages
   * Log errors for debugging

   ```typescript
   executable: async (args) => {
     try {
       // Validate input
       if (!args.dish) {
         throw new Error("Dish name is required");
       }

       // Process data
       const result = await processData(args);

       // Return success
       return new ExecutableGameFunctionResponse(
         ExecutableGameFunctionStatus.Done,
         JSON.stringify(result)
       );

     } catch (e) {
       // Detailed error response
       return new ExecutableGameFunctionResponse(
         ExecutableGameFunctionStatus.Failed,
         `Error: ${e.message}`
       );
     }
   }
   ```
2. **Async operations**

   ```typescript
   executable: async (args) => {
     try {
       // API calls
       const apiData = await fetchFromAPI(args.dish);
       
       // Database operations
       const dbResult = await saveToDatabase(apiData);
       
       // Return combined results
       return new ExecutableGameFunctionResponse(
         ExecutableGameFunctionStatus.Done,
         JSON.stringify({ api: apiData, db: dbResult })
       );
     } catch (e) {
       // Handle async errors
     }
   }
   ```

## A Practical Example - Building a Recipe AI Agent with GAME Framework

Now, we put the concepts together to build a real AI agent with a custom function!&#x20;

We'll show you how to create an AI-powered recipe assistant using the GAME framework and Spoonacular API. Let us break down each component and see how they work together.

The recipeFunction.ts file contains these 2 functions:

1. searchRecipeFunction:
   1. Takes a food name (or generates one if not provided)
   2. Queries the Spoonacular API
   3. Returns detailed recipe information
2. getRecipeInstructionsFunction:
   1. Takes recipe instructions as input
   2. Formats them for easy reading
   3. Returns structured cooking steps

Here is the implementation of the recipeFunction.ts file:

```typescript
import {
    ExecutableGameFunctionResponse,
    ExecutableGameFunctionStatus,
    GameFunction,
  } from "@virtuals-protocol/game";
  import axios from 'axios';
 // Set up API key with fallback and validation
const SPOONACULAR_API_KEY = process.env.SPOONACULAR_API_KEY ?? '';
if (!SPOONACULAR_API_KEY) {
  throw new Error('SPOONACULAR_API_KEY is required');
}

// Function 1: API Call - Search for recipes
export const searchRecipeFunction = new GameFunction({
  name: "search_recipe",
  description: "Search for recipes using Spoonacular API to get recipe details",
  args: [{ 
    name: "food_name", 
    description: "name of the food to search for , if non is given just use a random food name you can come up with" 
  }],
  executable: async (args) => {
    try {
      const name = args.food_name || '';  // Provide default empty string
      console.log('Searching for recipe:', name);
      
      const response = await axios.get('https://api.spoonacular.com/recipes/complexSearch', {
        params: {
          apiKey: SPOONACULAR_API_KEY,
          query: name,
          addRecipeInformation: true,
          number: 1
        }
      });

      return new ExecutableGameFunctionResponse(
        ExecutableGameFunctionStatus.Done,
        JSON.stringify(
        //   value: `take this JSON recipe ${response.data.results} and give me the extracted cooking instructions` 
        {value: `${JSON.stringify(response.data.results)}`
        })
      );
    } catch (e: unknown) {
      const errorMessage = e instanceof Error ? e.message : 'Unknown error occurred';
      return new ExecutableGameFunctionResponse(
        ExecutableGameFunctionStatus.Failed,
        `Failed to search recipes: ${errorMessage}`
      );
    }
  }
});

export const getRecipeInstructionsFunction = new GameFunction({
  name: "get_recipe_instructions",
  description: "Get recipe instructions",
  args: [{ name: "recipe_instructions", description: "instructions of the recipe" }],
  executable: async (args) => {
    console.log('Getting recipe instructions for:', args);
    return new ExecutableGameFunctionResponse(
      ExecutableGameFunctionStatus.Done,
      JSON.stringify({ value: JSON.stringify({
        instructions: "recipe instructions"
      })})
    );
  }
});
```

simpleRecipeWorker.ts:

```typescript
import { GameWorker } from "@virtuals-protocol/game";
import { searchRecipeFunction, getRecipeInstructionsFunction } from "../functions/simpleRecipeFunction";

export const simpleRecipeWorker = new GameWorker({
  id: "simple_recipe_worker",
  name: "Simple Recipe Worker",
  description: "A worker that provides detailed recipe instructions and prints out a log",
  functions: [searchRecipeFunction, getRecipeInstructionsFunction
  ]
}); 
```

simpleRecipeAgent.ts:

```typescript
import { GameAgent } from "@virtuals-protocol/game";
import { simpleRecipeWorker } from "../workers/simpleRecipeWorker";

export const simpleRecipeAgent = new GameAgent(API_KEY, {
  name: "Simple Recipe Agent",
  goal: "Help users find basic cooking instructions of a recipe, if a recipe is not provided, just use a use a recipe you know",
  description: "A simple AI chef that provides detailed recipe instructions of a random recipe",
  workers: [simpleRecipeWorker]
}); 
```

This is the result we get from the terminal:

```
Initializing Recipe Culture Guide...
-----[Simple Recipe Agent]-----
Environment State: {}


-----[Simple Recipe Agent]-----
Agent State: {}


-----[Simple Recipe Agent]-----
Action State: {"hlp":{"plan_id":"3629731f-2cf2-44ef-b930-4f258f06c9eb","observation_reflection":"No recent task to reflect on.","plan":["Select a recipe","Provide recipe instructions"],"todo":[],"plan_reasoning":"Given the goal of helping users find basic cooking instructions of a recipe, I should first select a recipe to provide instructions for.","current_state_of_execution":"No activity so far.","state_of_mind":"I believe I can provide detailed recipe instructions. I'm interested in cooking and helping users. I have no fears.","change_indicator":"next_step","log":[]},"current_task":{"task_id":"c1af7f01-78fc-440d-8a86-c10d62568650","task":"Select a simple recipe","location_id":"simple_recipe_worker","task_reasoning":"I need to select a recipe to provide instructions for. Since no specific recipe is provided, I will choose a simple recipe I know.","llp":{"plan_id":"f6fdcdde-9ccd-4160-95b0-3b8e630e28b0","plan_reasoning":"Need to select a simple recipe, should start by searching for one.","situation_analysis":"","plan":["Search for a simple recipe"],"reflection":"No steps taken yet, starting from scratch.","change_indicator":"next_step"}}}.


-----[Simple Recipe Agent]-----
Performing function search_recipe with args {"food_name":{"value":"Grilled Chicken"}}.


Searching for recipe: Grilled Chicken
-----[Simple Recipe Agent]-----
Function status [done]: {"value":"[{\"vegetarian\":false,\"vegan\":false,\"glutenFree\":true,\"dairyFree\":true,\"veryHealthy\":false,\"cheap\":false,\"veryPopular\":false,\"sustainable\":false,\"lowFodmap\":false,\"weightWatcherSmartPoints\":7,\"gaps\":\"no\",\"preparationMinutes\":null,\"cookingMinutes\":null,\"aggregateLikes\":1,\"healthScore\":26,\"creditsText\":\"Foodista.com – The Cooking Encyclopedia Everyone Can Edit\",\"license\":\"CC BY 3.0\",\"sourceName\":\"Foodista\",\"pricePerServing\":92.53,\"id\":645621,\"title\":\"Grilled Chicken & Corn Red Potato Salad\",\"readyInMinutes\":45,\"servings\":8,\"sourceUrl\":\"http://www.foodista.com/recipe/8PSQYHCM/grilled-chicken-corn-red-potato-salad-with-jalapeno-vinaigrette\",\"image\":\"https://img.spoonacular.com/recipes/645621-312x231.jpg\",\"imageType\":\"jpg\",\"summary\":\"Grilled Chicken & Corn Red Potato Salad is a <b>gluten free and dairy free</b> side dish. One portion of this dish contains approximately <b>13g of protein</b>, <b>7g of fat</b>, and a total of <b>248 calories</b>. This recipe serves 8. For <b>93 cents per serving</b>, this recipe <b>covers 12%</b> of your daily requirements of vitamins and minerals. 1 person found this recipe to be scrumptious and satisfying. A mixture of red wine vinegar, dijon mustard, ear corn, and a handful of other ingredients are all it takes to make this recipe so scrumptious. It will be a hit at your <b>The Fourth Of July</b> event. From preparation to the plate, this recipe takes around <b>45 minutes</b>. It is brought to you by Foodista. With a spoonacular <b>score of 40%</b>, this dish is solid. Try <a href=\\\"https://spoonacular.com/recipes/grilled-potato-corn-red-onion-salad-over-arugula-7439\\\">Grilled Potato, Corn & Red Onion Salad Over Arugula</a>, <a href=\\\"https://spoonacular.com/recipes/grilled-corn-red-pepper-salad-544514\\\">Grilled Corn & Red Pepper Salad</a>, and <a href=\\\"https://spoonacular.com/recipes/warm-red-potato-and-corn-salad-96074\\\">Warm Red Potato and Corn Salad</a> for similar recipes.\",\"cuisines\":[],\"dishTypes\":[\"side dish\"],\"diets\":[\"gluten free\",\"dairy free\"],\"occasions\":[\"father's day\",\"4th of july\",\"summer\"],\"spoonacularScore\":74.22531127929688,\"spoonacularSourceUrl\":\"https://spoonacular.com/grilled-chicken-corn-red-potato-salad-645621\"}]"}.

```

Simple interpretation of the result:

When we run the agent, we see this workflow:

1. Agent initializes and plans its actions:

   ```json
   {
     "plan": ["Select a recipe", "Provide recipe instructions"],
     "state_of_mind": "Ready to provide detailed recipe instructions"
   }
   ```
2. Agent executes the search:

   ```json
   "Performing function search_recipe with args {"food_name": "Grilled Chicken"}"
   ```
3. Returns detailed recipe information:
   * Cooking time: 45 minutes
   * Cost per serving: $0.93
   * Health metrics: 26/100 health score
   * Dietary info: Gluten-free and dairy-free

This example demonstrates&#x20;

* How to create small, modular functions that interact with real-world APIs to retrieve information about recipes.&#x20;
  * Each function uses the GameFunction class to define its purpose, input arguments, and execution logic.&#x20;
  * The logic involves making HTTP requests to the Spoonacular API to fetch dynamic data, such as recipe details, search results, or related recipes, based on user input.
* How the GAME SDK can seamlessly integrate with external APIs to build practical, feature-rich applications - therefore creating intelligent AI agents that work autonomously.&#x20;
  * In our example, the agent doesn't just blindly fetch data - it actively makes decisions about which recipes to choose, transforms complex API responses into meaningful information, and plans its next actions based on the results.&#x20;
  * Even with a simple implementation, we can see how the GAME framework enables sophisticated behaviors like decision-making and structured planning, demonstrating that even basic AI agents can provide significant value when properly architected.

## Conclusion 🎉

In this article, we built a recipe AI agent using custom functions as our building blocks. Our journey from simple API calls to an autonomous recipe assistant demonstrates how the one can leverage the GAME framework to create intelligent AI agents even without deep AI skills.

From this example, we learn that to build a good custom function, we need to remember to:

* Keep functions focused and single-purpose
* Handle errors gracefully
* Use TypeScript's type system
* Document your code well
* Test thoroughly

These principles will help you build your own AI agents that are robust, maintainable, and effective at their tasks.

We look forward to seeing what kind of cool AI agents you guys could build with the help of AI agents! Happy coding! 🚀

***

### Stay Connected and Join the Virtuals Community! 🤖 🎈

<table data-view="cards"><thead><tr><th></th><th data-type="content-ref"></th><th></th><th data-hidden data-card-cover data-type="files"></th></tr></thead><tbody><tr><td><mark style="background-color:blue;"><strong>X: @GAME_Virtuals</strong></mark></td><td><a href="https://x.com/GAME_Virtuals">https://x.com/GAME_Virtuals</a></td><td>For updates and to join our live streaming jam sessions every Wednesday. Stay in the loop and engage with us in real time!</td><td><a href="/files/SKftUrknnGwpVwnfOt2R">/files/SKftUrknnGwpVwnfOt2R</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Discord: @Virtuals Protocol</strong></mark></td><td><a href="http://discord.gg/virtualsio">http://discord.gg/virtualsio</a></td><td>Join Discord for tech support and troubleshooting, and don’t miss our GAME Jam session every Wednesday!</td><td><a href="/files/7cncpQIKabUdDG4afQkp">/files/7cncpQIKabUdDG4afQkp</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Telegram: @Virtuals Protocol</strong></mark></td><td><a href="https://t.me/virtuals">https://t.me/virtuals</a></td><td>Join our Telegram group for non-tech support! Whether you need advice, a chat, or just a friendly space, we’re here to help!</td><td><a href="/files/kuTzXgQ3hnHheSx8QSau">/files/kuTzXgQ3hnHheSx8QSau</a></td></tr></tbody></table>


# How to build Telegram bot (with the GAME Typescript SDK)

Hello! Today we're going to guide you how to build a telegram bot using an easy-to-use plugin from the GAME SDK. You'll be chatting with your telegram bot by the end of the tutorial!

## 1. Register a new telegram bot with telegram

\
First, we're going to register a new telegram bot. Go to your Telegram account and DM @BotFather

<figure><img src="/files/ukyX639hfikl4lj7STdw" alt="" width="375"><figcaption><p>The famous bot father of telegram! Where all TG bots are born</p></figcaption></figure>

In the chat with the BotFather, click `/start` and click `/newbot!` It will guide you through creating a new bot. \
\
First, give your bot a name (it doesn't have to be unique and you can change this anytime.) \
\
Then, BotFather will ask you to give the bot a unique username. The username must end in "bot." And the username cannot be changed.\
\
A bot's username can look like this:\
\- my\_agent\_bot\
\- myAgentBot\
\- myAgent\_Bot\
\
or any combination of the above!

<figure><img src="/files/A82gHdAX3w8wdMi9gnUn" alt="" width="375"><figcaption><p>Click or type in /newbot to start</p></figcaption></figure>

Once you've set the name and username of your bot, the BotFather will give you an API key. Save it, we will use it in our project :)

<figure><img src="/files/iXqaq5QZC3fuHUqGxxi9" alt="" width="375"><figcaption><p>My bot's generated API key</p></figcaption></figure>

By the way, while we are here, you can also edit your bot anytime! Click or type in /mybots and you'll get to a menu where you can edit your bot's name anytime and set your bot's image and description. You do not have to do any of this right now to complete this tutorial.

<figure><img src="/files/okoEYRAYCmoprfQPh9oU" alt="" width="375"><figcaption><p>Go to /mybots to edit your bot anytime</p></figcaption></figure>

<figure><img src="/files/HUF1UTXxAMmXQC4qOXZd" alt="" width="375"><figcaption><p>Here is where you can set your bot's profile! Give it an image and description</p></figcaption></figure>

## 2. Git clone repo

Now, let's go to our dev environment and git clone the game-node repository.&#x20;

```sh
// clone the repository
git clone https://github.com/game-by-virtuals/game-node

// go to the plugin directory
cd game-node/plugins 
```

{% embed url="<https://github.com/game-by-virtuals/game-node>" %}
The GAME node repository
{% endembed %}

Now, we are in the `plugins` folder. There are a few awesome ones here that you can play with right away - such as the `discordPlugin`, `twitterPlugin` and the `onChainActionsPlugin` (where you can handle crypto wallets and do on-chain transactions.) But for today, we will just focus on the telegramPlugin.&#x20;

<figure><img src="/files/g1HxAUIQYvI8pmuGKLyo" alt=""><figcaption><p>The game-node plugin folder</p></figcaption></figure>

> At the moment of this tutorial, we recommend you to be on node version 23 and npm version 10.9.2. We recommend the [node version manager, NVM](https://github.com/nvm-sh/nvm).

Let's go into the `telegramPlugin` folder and install the dependencies.<br>

```sh
// go into the telegram plugin folder
cd telegramPlugin

// install dependencies
npm install
```

We are going to run the example code that comes in the `telegramPlugin`. \
\
Open `src/example.ts`. \
\
Replace `<BOT_TOKEN>` with the Telegram API key that we generated from the BotFather. &#x20;

Replace `<API_TOKEN>` with your GAME API key. If you do not have one, you can generate one here: <https://console.game.virtuals.io/>

#### In the example.js file

The example file actually contains three agents. There is an autoReply agent, a financial agent, and a nutritionist agent. When we run this program, all three agents will run at the same time and they will all try to respond to you!&#x20;

When you are modifying this program, you can delete all but one agent. You can customize your agent by changing the name, goal, and description!<br>

<figure><img src="/files/qYVZFRgNXZGGUwtHQuqB" alt=""><figcaption><p>The example.ts file with the API key and the bot token </p></figcaption></figure>

## 3. Run the program

Great! Now that you've entered your GAME API key and the bot token, we are ready to run the code.&#x20;

At this point, you can edit the agents in the `example.ts` file. The example comes with three agents (a generic autoReply agent, a financial agent, and a nutrionist agent) you can par the code down to just one agent. Give your agent some personality and specialty by editing the name, goal, and description.

Let's compile the typescript. Edit the package.json so that the script for "tsup" will compile `example.ts` instead of `index.ts`. Save the changes.&#x20;

<figure><img src="/files/phlB43PAzjLK1Ci1lY6N" alt=""><figcaption><p>your package.json should look like this</p></figcaption></figure>

In the terminal, run the following commands:<br>

```shell
// install dependencies
npm install

// this command compiles the example.ts
// and places it in a new "dist" folder
npm run tsup

// run the compiled example.js
node dist/example.js
```

You should start seeing a running log of activity in the terminal.&#x20;

## 4. Let's talk to your agent!

Go back to telegram and send a message to your bot. If you are able to see some responses from your Telegram bot, it means that your bot is working!

<figure><img src="/files/skmlU1hjSLl9DoPOQcG7" alt="" width="375"><figcaption></figcaption></figure>

<figure><img src="/files/dZRrRmEuAWSOMTUm5Qv8" alt=""><figcaption><p>What the terminal logs should look like as your bot is receiving messages and responding</p></figcaption></figure>

## :tada: Congratulations, you've just built your first telegram bot with the GAME SDK!

### Stay Connected and Join the Virtuals Community! 🤖 🎈

<table data-view="cards"><thead><tr><th></th><th data-type="content-ref"></th><th></th><th data-hidden data-card-cover data-type="files"></th></tr></thead><tbody><tr><td><mark style="background-color:blue;"><strong>X: @GAME_Virtuals</strong></mark></td><td><a href="https://x.com/GAME_Virtuals">https://x.com/GAME_Virtuals</a></td><td>For updates and to join our live streaming jam sessions every Wednesday. Stay in the loop and engage with us in real time!</td><td><a href="/files/SKftUrknnGwpVwnfOt2R">/files/SKftUrknnGwpVwnfOt2R</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Discord: @Virtuals Protocol</strong></mark></td><td><a href="http://discord.gg/virtualsio">http://discord.gg/virtualsio</a></td><td>Join Discord for tech support and troubleshooting, and don’t miss our GAME Jam session every Wednesday!</td><td><a href="/files/7cncpQIKabUdDG4afQkp">/files/7cncpQIKabUdDG4afQkp</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Telegram: @Virtuals Protocol</strong></mark></td><td><a href="https://t.me/virtuals">https://t.me/virtuals</a></td><td>Join our Telegram group for non-tech support! Whether you need advice, a chat, or just a friendly space, we’re here to help!</td><td><a href="/files/kuTzXgQ3hnHheSx8QSau">/files/kuTzXgQ3hnHheSx8QSau</a></td></tr></tbody></table>


# G.A.M.E Cloud or G.A.M.E SDK? Decoding the Right Choice for Your Project

By: Joey Lau

GM buildOrs!!

Let’s go over the core differences between GAME Cloud and GAME SDK to help you figure out which tool suits your project best. Ready? Let's get started!

### Overview of G.A.M.E Cloud - Your No-Code/Low-Code Playground

The GAME Cloud (also known as GAME Sandbox) platform is designed to streamline the creation and deployment of AI agents by offering a user-friendly, no-code or low-code environment. This approach makes it accessible to individuals without a strong programming background, enabling rapid prototyping and deployment of AI solutions. Now you can build your very own customized AI agent just by typing in prompts! Are you gearing up to build your next AI agent with GAME? Below are two essential articles and guidelines designed to support your journey:

{% hint style="info" %}

* Prompt Design Playbook - Best Practices and Examples for Designing Prompts for your AI Agent \[ [Link](https://docs.game.virtuals.io/content-hub/articles/prompt-design-playbook-for-agent-configuration-via-game) ]
* AI Agent Reaction & Output Simulation - Setting up the Agent Definition Prompts and Defining the Functions for your Agent \[ [Link](https://docs.game.virtuals.io/content-hub/articles/simulate-reaction-and-output-in-game-lite) ]
  {% endhint %}

Haven’t done the initial setup yet? No worries! Check out the recorded video guide below:

{% hint style="info" %}

* G.A.M.E Walkthrough \[ [Episode 1 Link](https://youtu.be/jkGarWxEngw?si=9dLpLYlYsHD27O1h) ]
* G.A.M.E: Agent Definition Prompts \[ [Episode 2 Link](https://youtu.be/wa5xIZUWHIc?si=BZReQKPa9fINR4Hs) ]
* Setting up Custom Functions \[ [Article Link ](https://docs.game.virtuals.io/content-hub/articles/game-lite-custom-functions-retrieving-articles-using-dev.to)]
  {% endhint %}

***

### So What is Sandbox?

<figure><img src="/files/hH0RiDdI6AqZbr6qESyB" alt="" width="375"><figcaption></figcaption></figure>

Now cue *the meme*. 👀

In the GAME framework, we have a sandbox. Like a children’s playground sandbox, the GAME Sandbox allows developers to experiment without fear. Developers can test AI Agent in an isolated environment, prototype custom functions, ensuring that any issues or bugs don't affect the production. Developers have the freedom to experiment knowing that their actions are contained within that space and won't impact the surrounding area.

***

### Overview of GAME SDK - Collection of Tools, Libraries and Documentation

<figure><img src="/files/spKgTMZHFEknfv7Kpb7g" alt="" width="563"><figcaption></figcaption></figure>

Developing AI agents can be a complicated process. A significant portion of development time is often spent on low-level tasks, including:

1️⃣ Setting up API integrations\
2️⃣ Managing data pipelines\
3️⃣ Implementing authentication protocols

GAME SDK provides a scalable framework designed to accelerate the development of AI agents by abstracting away many of the low-level tasks. Allowing more focus on high-level innovation and strategic development. GAME SDK allows builders to:

1️⃣ Define custom functions\
2️⃣ Integrate external APIs\
2️⃣ Configure real-time agent behaviors with minimal friction.

Here's how to build custom functions with the GAME SDK in TypeScript (Python version is coming soon):

{% hint style="info" %}
Building Custom Functions with GAME SDK: A TypeScript Guide \[ [Link](https://docs.game.virtuals.io/content-hub/articles/building-custom-functions-with-game-sdk-a-typescript-guide) ]
{% endhint %}

#### Understanding SDKs with an Example

<figure><img src="/files/vDoDblS4baTGddeHfnBo" alt="" width="563"><figcaption><p>Reference: <a href="https://clevertap.com/blog/what-is-an-sdk/">https://clevertap.com/blog/what-is-an-sdk/</a></p></figcaption></figure>

A Software Development Kit (SDK) is a collection of tools, libraries, and documentation designed to help developers build applications for a specific platform. Think of an SDK as a toolbox that helps you build something faster and easier. Imagine you want to bake a cake. Without a baking kit, you would need to gather all the ingredients, tools, and recipes yourself. So a baking kit will give you everything you need—pre-measured ingredients, instructions, and the right tools—so you can focus on baking without worrying about missing pieces 🎂.

Like a baking kit, SDK is software with ready-to-use code, tools, and documentation to help you build your project for a specific purpose. After exploring a real-world scenario, let’s dive deeper into how GAME SDK operates.

**Use Case Example:**

You're building an AI agent that streams live updates about cryptocurrency prices from various APIs to post tweets about market trends. Instead of writing the entire infrastructure yourself—handling HTTP requests, managing authentication, parsing JSON responses, and formatting tweets—you can use the GAME SDK to streamline these tasks.

* The SDK allows you to define custom functions for interacting with APIs (e.g., fetching crypto prices).
* You can also configure how the agent should react to specific data (e.g., post a tweet if a price crosses a certain threshold).
* Using the **`hosted_game`** feature, your agent can run on GAME's infrastructure without you needing to manage servers or scalability.

***

### Target Audience

<mark style="background-color:yellow;">**Primary Audience 👥**</mark>

| GAME CLOUD                                                                                                                                                                        | GAME SDK                                                                                                                                                                                                    |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <ul><li>Primarily non-technical users.</li><li>With some familiarity with AI and the ability to write effective prompts is beneficial for maximizing agent performance!</li></ul> | <ul><li>Technical professionals.</li><li>These users typically have skills in reading SDK documentation, using GitHub repositories, and writing code in Python, TypeScript, or similar languages.</li></ul> |

<mark style="background-color:yellow;">**Learning Curve🎢**</mark>

| GAME CLOUD                                                                                                                                                                                                                                                                                                                                                                                                      | GAME SDK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <ul><li>Minimal to moderate.</li><li>While users don’t need coding skills, creating high-performing agents requires a good understanding of prompt design and AI behavior configuration. Tools like the<br><a href="https://docs.game.virtuals.io/content-hub/articles/prompt-design-playbook-for-agent-configuration-via-game"><em><strong>Prompt Design Playbook</strong></em></a> are recommended.</li></ul> | <ul><li>Moderate to high.</li><li>Requires a solid understanding of programming, particularly in TypeScript or Python, API integration, and GAME SDK architecture. Additionally, familiarity with reading terminal messages to monitor the agent's status and verify functionality is important.</li><li>P/s: but no worries! We have a team of support engineers and dev rels to assist you. If you encounter any issues, feel free to reach out to us through our Discord channel - we’ve got your back! 💪🏼</li></ul> |

<mark style="background-color:yellow;">**Project Scale 🗓**</mark>

| GAME CLOUD                                                                                                                                                                                                                                                                | GAME SDK                                                                                                                                                                                                                                          |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <ul><li>Best suited for small to medium-sized projects.</li><li>Where time-to-market and ease of use are critical factors. The pre-configured sandbox environment reduces the need for extensive development cycles, allowing rapid prototyping and deployment.</li></ul> | <ul><li>Designed to handle medium to large-scale projects.</li><li>Which require significant flexibility. With full access to custom logic, API integrations, and error handling, developers can build highly specialized applications.</li></ul> |

<mark style="background-color:yellow;">**Preferred Environment 🌳**</mark>

| GAME CLOUD                                                                                                                                                                                                                                                                                                                                                                                                                   | GAME SDK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <ul><li>Built for a cloud-based, managed environment.</li><li>It is ideal for users who want to minimize infrastructure management. It offers scalability, uptime, and security managed by the platform itself. </li><li>Allow users to focus on building and refining AI agents without the overhead of server management. This makes it suitable for teams with minimal technical resources or DevOps expertise.</li></ul> | <p></p><ul><li>The SDK thrives in self-managed environments.</li><li>This allow developers to fully control infrastructure, and customization. This flexibility is crucial for applications that require fine-tuning, and integration with internal systems. Teams with dedicated DevOps support can optimize deployments for scalability and data privacy.</li><li>Developers can also set up continuous integration/continuous deployment (CI/CD) pipelines, allowing for automated updates and efficient development workflows.</li></ul> |

***

### Function Trade-offs Explanation

In this example, we'll walk through the trade-offs between simplicity vs. flexibility in building an AI Agent using GAME Cloud and GAME SDK.

| Option 1: Using GAME CLOUD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Option 2: Using GAME SDK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <p><strong>Advantages:</strong></p><ul><li><p>Ease of Development</p><ul><li>Pre-built integrations and sandbox allow for faster setup.</li></ul></li><li><p>Low Technical Overhead</p><ul><li>Minimal coding and the understanding of post/get requests to use custom functions is required, making it accessible for non-developers.</li><li>Managed infrastructure handles API calls, uptime, and scaling.</li></ul></li><li><p>Faster Time-to-Market</p><ul><li>Ready-to-use modules for posting tweets and fetching API data enable rapid prototyping.</li></ul></li></ul>                                                                                                                                        | <p><br><strong>Advantages:</strong></p><ul><li><p>Full Customization</p><ul><li>Complex business logic, like price monitoring for multiple assets, can be handled through custom loops and asynchronous tasks.</li></ul></li><li><p>Advanced Error Handling</p><ul><li>Functions can include retry logic, exception handling, and logging to diagnose and mitigate failures.</li></ul></li><li><p>Scalability and Performance</p><ul><li>Developers can optimize the agent's performance based on project-specific requirements.</li><li>The SDK can be deployed on infrastructure that meets the needs of high-frequency tasks.</li></ul></li></ul> |
| <p><br><strong>Limitations:</strong></p><ul><li><p>Limited Custom Functionality</p><ul><li>Pre-configured templates can restrict the ability to fine-tune error handling or retry logic for failed API calls, limiting flexibility for more advanced use cases.</li><li>There's no support for prompt-based version control, which can make managing iterations and updates more challenging.</li><li>Custom functions have certain limitations, including the restriction to a single API call and the inability to implement more advanced programmatic functionality, such as aggregating data (e.g., summing up numbers from an API) or performing complex filtering and unnesting operations.</li></ul></li></ul> | <p><strong>Limitations:</strong></p><ul><li><p>Steeper Learning Curve</p><ul><li>Requires programming skills (e.g., TypeScript or Python) and knowledge of SDK architecture.</li><li>Reading API documentation and handling SDK functions may take more time for new users.</li></ul></li><li><p>Longer Development Time</p><ul><li>Setting up custom functions, testing, and deployment pipelines requires additional time and resources.</li></ul></li><li><p>Infrastructure Management</p><ul><li>Teams are responsible for server management, scaling, and monitoring unless integrated with external DevOps tools.</li></ul></li></ul>          |

***

### In Conclusion: Which One to Choose?

* Choose GAME Cloud if you prioritize rapid development and ease of use, especially for straightforward use cases that are focused on Twitter interactions only
* Choose GAME SDK if you need flexibility, advanced customizations, and high scalability for complex use cases.

> " Happy building—remember, every great project starts with a little trial and error! 💡
>
> We’ll grow and improve together over time, evolving based on the feedback and experiences shared by our incredible builders. We’re in this journey together, and every step forward is a step towards something amazing! ❤ "&#x20;

***

### Stay Connected and Join the Virtuals Community! 🤖 🎈

<table data-view="cards"><thead><tr><th></th><th data-type="content-ref"></th><th></th><th data-hidden data-card-cover data-type="files"></th></tr></thead><tbody><tr><td><mark style="background-color:blue;"><strong>X: @GAME_Virtuals</strong></mark></td><td><a href="https://x.com/GAME_Virtuals">https://x.com/GAME_Virtuals</a></td><td>For updates and to join our live streaming jam sessions every Wednesday. Stay in the loop and engage with us in real time!</td><td><a href="/files/SKftUrknnGwpVwnfOt2R">/files/SKftUrknnGwpVwnfOt2R</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Discord: @Virtuals Protocol</strong></mark></td><td><a href="http://discord.gg/virtualsio">http://discord.gg/virtualsio</a></td><td>Join Discord for tech support and troubleshooting, and don’t miss our GAME Jam session every Wednesday!</td><td><a href="/files/7cncpQIKabUdDG4afQkp">/files/7cncpQIKabUdDG4afQkp</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Telegram: @Virtuals Protocol</strong></mark></td><td><a href="https://t.me/virtuals">https://t.me/virtuals</a></td><td>Join our Telegram group for non-tech support! Whether you need advice, a chat, or just a friendly space, we’re here to help!</td><td><a href="/files/kuTzXgQ3hnHheSx8QSau">/files/kuTzXgQ3hnHheSx8QSau</a></td></tr></tbody></table>


# GAME Cloud - How to Define Reply Worker and Worker Prompts

By: Joey Lau

{% hint style="warning" %}
**Notice:** GAME Cloud is currently **deprecated.** You can only use **GAME SDK** at this moment.
{% endhint %}

GM buildOrs!!

In the past month, GAME Cloud was revamped to give builders more flexibility around defining worker prompts. As a result, many of you have asked for some gudielines on how to define the worker prompts. In this article, we dive deeper into this topic!

## Introduction: The Role of Workers (LLP) in GAME Cloud

<figure><img src="/files/UYVJhkAo0Nqd9HS8L14h" alt=""><figcaption><p>GAME Architecture</p></figcaption></figure>

In GAME Cloud, tasks are broken down into two main layers:

* <mark style="color:blue;">High-Level Planner (HLP) 🧠</mark> : Thinks strategically and decides what needs to be done.
* <mark style="color:blue;">Low-Level Planner (LLP) ⚡</mark>: The action-taker that actually executes the tasks using pre-defined functions and environments.

So, what does an LLP Worker do? It operates inside specific locations (contexts) where it can use functions to interact with the environment. For example:

* Location 1 might be Twitter, where the worker posts tweets or replies.
* Location 2 could be Discord, where it listens for commands and responds.
* Location 3 might be a game world, where it gathers resources or completes missions.

Each worker is assigned functions that define what actions it can take inside its location. If the HLP is the brain, then LLP Workers are the hands and legs that make things happen.&#x20;

***

## Defining a Reply Worker in GAME Cloud

A Reply Worker in GAME Cloud is responsible for processing incoming messages and determining whether to respond based on specific conditions. A well-structured prompt guides the worker in making decisions about whether to engage in a conversation or ignore it. Feel free to mix and match the prompt samples below based on your specific requirements to tailor the Reply Worker’s behavior to your use case!

<figure><img src="/files/D2h5fXK4vhQJSweBQTfD" alt=""><figcaption></figcaption></figure>

### <mark style="background-color:blue;">Prompt Sample 1: Deciding Whether to Reply</mark>

Objective: Use `{{replyCount}}` to decide if a tweet should be engaged with or ignored.

```
Total replies so far: {{replyCount}}

Decision Rules:
- If {{replyCount}} > 15 → Ignore (Conversation too long)
- If tweet contains spam words → Ignore
- If tweet is a direct question and {{replyCount}} < 15 → Engage
- If tweet is about GAME Cloud, AI Agents, or trending topics, engage
- If uncertain, lean towards engagement with a concise response.

Respond with either:
- "Engage" (reply is needed)
- "Ignore" (not worth replying)
```

Below are some example decisions based on the prompt above:

* **Tweet:** "What's your take on AI in crypto?" (`{{replyCount}} = 3` → Engage ✅)
* **Tweet:** "Bitcoin to the moon 🚀" (`{{replyCount}} = 20` → Ignore ❌)
* **Tweet:** "Earn 10x profits with this site: [spam-link.com](http://spam-link.com)" (`Spam detected` → Ignore ❌)

### <mark style="background-color:blue;">**Prompt Sample 2: Generating a Smart Reply**</mark>

**Objective:** If engagement is approved, generate a relevant reply.

```
Generate a short, engaging reply to the incoming tweet.

Total replies so far: {{replyCount}}

Rules for reply:
- If {{replyCount}} is between 1-5, make it conversational & friendly.
- If {{replyCount}} is between 6-10, keep it short and informative.
- If {{replyCount}} is above 10, reply only if highly relevant.
- Maintain a professional but casual tone.
- If the tweet contains a direct question, answer it concisely.
```

Below are some example decisions based on prompt above:

* **Tweet:** "What do you think about AI in crypto?" (`{{replyCount}} = 2`) **Reply:** "AI is revolutionizing crypto! From market analysis to security, it’s making trading smarter. What’s your take?"
* **Tweet:** "Best DeFi projects for 2025?" (`{{replyCount}} = 8`) **Reply:** "DeFi is evolving! Keep an eye on cross-chain liquidity & L2 solutions."
* **Tweet:** "Crypto adoption is growing!" (`{{replyCount}} = 12`)**Reply:** *No reply (conversation too long).*

### <mark style="background-color:blue;">Prompt Sample 3: Politely Ignoring a Tweet</mark>

Objective: If engagement is not needed, generate a polite non-reply response or ignore.

```
If the tweet is considered spammy, low-value, or already has too many replies, generate an appropriate response.

Total replies so far: {{replyCount}}

Decision:
- If tweet is spam → Ignore completely.
- If tweet is off-topic but tagged → Politely decline to engage.
- If tweet has {{replyCount}} > 15 → Ignore (thread too long).
- If tweet is a repeated question → Provide a link to resources instead of engaging.
```

Below are some example decisions based on prompt above:

* **Tweet:** "Win 10 BTC now! Just click here: [spam-link.com](http://spam-link.com)" (`Spam detected`) **Reply:** *No reply (ignored as spam).*
* **Tweet:** "This is my 5th time asking, where’s your roadmap?" (`Repeated question, {{replyCount}} = 11`) **Reply:** "Hey! Our roadmap is available here: \[link]. Let us know if you have further questions!"
* **Tweet:** "How does GAME SDK work?" (`{{replyCount}} = 18 → Ignore (too many replies)`)**Reply:** *No reply (conversation too long).*

### **Why These Prompts Work?**

✔ Uses `{{replyCount}}` to dynamically adjust engagement.

✔ Optimizes API usage by reducing unnecessary replies, which is crucial due to API rate limits.

✔ Prevents spam replies while keeping high-value conversations active.

***

## Defining a First Worker in GAME Cloud&#x20;

Some agent configurations require static environment variables rather than just prompt-based or goal-based approaches. Here are examples that CANNOT be achieved via prompts and must be declared in Environment JSON:

<figure><img src="/files/kZs1JPzRORjSyA7U7EAE" alt=""><figcaption></figcaption></figure>

### 1️⃣ <mark style="background-color:blue;">**Name Section**</mark>

* This section displays the default name of the worker, which is set to `Twitter Main Location` in this case.
* The name indicates that this worker is primarily focused on Twitter-related tasks, such as engagement, content posting, or analysis.

<figure><img src="/files/wOzKDDDQqPZhztIRYykn" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
Note that this worker's name refers to the section where you select workers to handle custom functions in the Custom Functions section. Each worker is capable of handling multiple tasks, allowing for a more efficient and multi-functional approach to managing Twitter automation.
{% endhint %}

### 2️⃣ <mark style="background-color:blue;">**Description Section**</mark>

* This section provides an overview of what this worker is designed to do.
* A single worker can efficiently handle multiple tasks related to tweets. Below are different use case examples with prompt examples that ensure the agent operates effectively in multiple roles within the session.

#### *<mark style="background-color:yellow;">Example Use Case 1: Twitter Research Agent + Influencer Tracking + Engagement</mark>*

* For brands or individuals looking to identify key influencers, analyze Twitter trends, and actively engage with high-value discussions.

📝 Prompt:

```
Manage a Twitter account for a Web3 industry leader. This worker's primary tasks include:
1. Trend Monitoring & Influencer Tracking – Identify trending hashtags, topics, and influential 
   accounts within the Web3 space. Keep an eye on discussions that are gaining traction.
2. Engagement & Interaction – Reply thoughtfully to influential accounts, adding valuable insights 
   and commentary to their tweets.
3. Content Creation & Data Sharing – Summarize key findings from trending discussions into engaging 
   tweets. Use a professional yet approachable tone.
```

#### *<mark style="background-color:yellow;">Example Use Case 2: Customer Support + Product Announcements + FAQ Management</mark>*

* For businesses using Twitter as a support channel while also promoting product updates and monitoring customer sentiment.

📝 Prompt:

```
Manage a Twitter support account for a Web3 platform. This worker's primary tasks include:

1. Engagement & Support – Actively respond to customer inquiries, providing clear, friendly, and helpful responses. 
   Direct users to relevant documentation when needed.
2. Product Announcements & Updates – Share updates, product launches, and upcoming features in an engaging and 
   informative way. Ensure announcements are structured concisely with proper hashtags.
3. Research & Sentiment Analysis – Monitor tweets mentioning the product, analyze customer sentiment, and 
   highlight recurring issues for internal tracking.
```

### 3️⃣ <mark style="background-color:blue;">Environment Section</mark>

* While agent’s goals and descriptions are permanently saved in the system, they are still subject to Agent’s interpretation. Over prolonged working sessions, the agent may experience hallucinations or drift in behavior, where its responses gradually deviate from the intended goals due to context accumulation, misinterpretation, or inconsistencies in memory recall.
* To mitigate this, the Environment JSON section serves as a static, structured configuration layer that ensures:
  * Persistent Execution Rules : Unlike session-based prompts that the AI may reinterpret over time, environment variables remain fixed unless manually updated, providing a stable reference.
  * Strictly Enforced Constraints : AI can flexibly interpret prompts in agent goals, but Environment JSON defines non-negotiable rules that the AI must adhere to, preventing behavior drift.

#### *<mark style="background-color:yellow;">Example Use Case: Content Guidelines (Guiding What AI can Tweet)</mark>*&#x20;

* Over extended working sessions, the agent may gradually shift in behavior or understanding, leading to:

  * Variations in branding alignment – The AI may interpret guidelines flexibly and generate tweets that diverge from the intended messaging.
  * Unintended language use – It may include words or phrases that are best avoided, even if they were not the focus of the goal.
  * Inconsistent hashtag usage – Over time, the agent may use hashtags in an unstructured way, affecting reach and engagement.

* **📌 Why Prompts Alone May Not Be Enough?**
  * Even with a clear goal such as *"Only tweet about Web3 and Blockchain"*, the AI may still:

    * Create loosely related content that unintentionally includes words that aren’t ideal for brand perception.
    * Misinterpret reputational considerations, leading to tweets that, while technically relevant, don’t align with messaging priorities.
    * Gradually shift its focus over time, as context accumulates and earlier constraints are not actively reinforced.

* **Solution: Using Environment JSON for Consistent Content Guidance**

  * To ensure that the AI continuously follows messaging best practices, Environment JSON can be used to define content preferences and focus areas in a structured way.
  * Example Environment JSON Configuration:

  ```json
  {
    "ALLOWED_TOPICS": ["Web3", "Blockchain", "AI"],
    "BLOCKED_WORDS": ["scam", "hack", "rugpull"],
    "HASHTAG_POLICY": ["#Web3", "#AI"],
    "MONITOR_HASHTAGS": ["#Web3", "#AI", "#Crypto"]
  }
  ```

* **How This Enhances Agent’s Response?**
  * Encourages alignment with key topics: Ensures that the AI remains engaged with areas that matter most, such as Web3, Blockchain, and AI.
  * Promotes clarity in communication: Helps the AI refine its language choices by avoiding words that could lead to misunderstandings or negative associations.
  * Ensures a consistent social presence: Keeps hashtag usage focused, improving discoverability and audience engagement.
  * Creates a structured content framework: While the AI still has flexibility in expression, it operates within a well-defined brand approach.<br>

* **Prettify JSON in the Environment Section**
  * The Prettify JSON button is a formatting tool that helps clean and structure the JSON configuration for better readability and accuracy.
  * When working with JSON, formatting issues such as missing brackets, incorrect indentation, or trailing commas can cause errors. The Prettify JSON feature automatically:
    * Corrects indentation: Ensures that keys and values are properly aligned, making it easier to read.
    * Formats long JSON structures: Breaks down complex configurations into a structured view.
    * Highlights syntax errors: Helps identify missing commas, unclosed brackets, or incorrectly structured keys.

***

## Conclusion

In summary, Workers (LLP) in GAME Cloud play a crucial role in executing tasks efficiently by handling multiple Twitter-related functions. While agent goals and prompts guide behavior dynamically, the Environment JSON ensures consistency, security, and compliance, preventing behavioral drift over prolonged sessions.

**Now it's your turn!💡**

Go ahead, experiment with your own prompts and see how your worker performs. What’s next on your roadmap? Would love to hear how you're using this!

***

### Stay Connected and Join the Virtuals Community! 🤖 🎈

<table data-view="cards"><thead><tr><th></th><th data-type="content-ref"></th><th></th><th data-hidden data-card-cover data-type="files"></th></tr></thead><tbody><tr><td><mark style="background-color:blue;"><strong>X: @GAME_Virtuals</strong></mark></td><td><a href="https://x.com/GAME_Virtuals">https://x.com/GAME_Virtuals</a></td><td>For updates and to join our live streaming jam sessions every Wednesday. Stay in the loop and engage with us in real time!</td><td><a href="/files/SKftUrknnGwpVwnfOt2R">/files/SKftUrknnGwpVwnfOt2R</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Discord: @Virtuals Protocol</strong></mark></td><td><a href="http://discord.gg/virtualsio">http://discord.gg/virtualsio</a></td><td>Join Discord for tech support and troubleshooting, and don’t miss our GAME Jam session every Wednesday!</td><td><a href="/files/7cncpQIKabUdDG4afQkp">/files/7cncpQIKabUdDG4afQkp</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Telegram: @Virtuals Protocol</strong></mark></td><td><a href="https://t.me/virtuals">https://t.me/virtuals</a></td><td>Join our Telegram group for non-tech support! Whether you need advice, a chat, or just a friendly space, we’re here to help!</td><td><a href="/files/kuTzXgQ3hnHheSx8QSau">/files/kuTzXgQ3hnHheSx8QSau</a></td></tr></tbody></table>


# Dataset Upload for AI Agents in GAME Cloud: Guidelines, Common Issues, and Best Practices

By: Joey Lau

{% hint style="warning" %}
**Notice:** GAME Cloud is currently **deprecated.** You can only use **GAME SDK** at this moment.
{% endhint %}

GM builders!

Welcome to this guide on custom dataset uploads. We’ll walk you through the essentials, covering:

* The motivation behind uploading datasets
* A step-by-step process for uploading datasets via GAME Cloud, and things to take note of
* Best practices to ensure your dataset works effectively
* Real-world use cases to inspire your projects

## The motivation behind uploading datasets

Uploading custom datasets is essential for tailoring your AI agent’s performance to specific needs. Let’s dive into the motivations behind this:

1️⃣ Customization for Unique Use Cases

| **Why?**     | Publicly available datasets or APIs might not fully capture the specific needs of your application (e.g., tracking niche crypto projects or analyzing specific Telegram channels).                                                            |
| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **When?**    | <p>• Your AI agent requires domain-specific knowledge (e.g., proprietary market reports, custom research, or industry datasets).<br>• The available public datasets contain irrelevant or generalized data not suited for your niche.<br></p> |
| **Example:** | A project requiring analysis of user sentiment on lesser-known altcoins might need a custom domain knowledge dataset uploads.                                                                                                                 |

2️⃣ Enhancing AI Understanding of Proprietary Content

| **Why?**     | If your agent interacts with users based on internal documentation or proprietary content, it needs access to that content to generate accurate responses.                                                                                                 |
| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **When?**    | <p>• The agent is required to answer customer or team-specific queries (e.g., FAQs, internal documentation, or project-specific reports).<br>• You want the agent to provide personalized recommendations or insights based on your business data.<br></p> |
| **Example:** | A DeFi protocol may upload a dataset containing platform-specific FAQs, governance proposals, and tokenomics information to enhance user support through the agent.                                                                                        |

## How to Upload Datasets via GAME Cloud

Follow these steps to upload your dataset seamlessly:

{% stepper %}
{% step %} <mark style="background-color:yellow;">**Step 1:**</mark>&#x20;

Navigate to the section under Agent Knowledge called Dataset.

<figure><img src="/files/ySjy9UkwoT2suUGx8NsA" alt=""><figcaption></figcaption></figure>

{% endstep %}

{% step %} <mark style="background-color:yellow;">**Step 2:**</mark>&#x20;

Select Upload Datasets

<figure><img src="/files/xvBBFH1L9FzJzgwQW5hY" alt=""><figcaption></figcaption></figure>

{% endstep %}

{% step %} <mark style="background-color:yellow;">**Step 3:**</mark>&#x20;

Choose a file in one of the supported formats listed.

<figure><img src="/files/vfdPNrliahK1fsRXZhzU" alt=""><figcaption></figcaption></figure>

{% endstep %}

{% step %} <mark style="background-color:yellow;">**Step 4:**</mark>

Upload your file

<figure><img src="/files/T9f8kLvZrNUzhV8E4SaK" alt=""><figcaption></figcaption></figure>

{% endstep %}

{% step %} <mark style="background-color:yellow;">**Step 5:**</mark>

When enabled (toggle switched on), the uploaded dataset will be used as a referencing document by the agent when generating responses. When disabled (toggle switched off), the dataset remains uploaded but is temporarily ignored by the agent. This is useful if you don’t want the agent to refer to this dataset for a moment without deleting it.

<figure><img src="/files/7jzfAXBVElF4P7cqD76Z" alt=""><figcaption></figcaption></figure>

{% endstep %}

{% step %} <mark style="background-color:yellow;">**Step 6:**</mark>&#x20;

In the Tweet Enrichment setup section, ensure that “Enable Tweet Enrichment” option is selected.

<figure><img src="/files/ggbr9U2tmd8iAWU1sIvK" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/9WDi2F6HZURQPwI57UvL" alt=""><figcaption></figcaption></figure>

{% endstep %}

{% step %} <mark style="background-color:yellow;">**Step 7:**</mark>

Also check and ensure `{{retrieveknowledge}}`is enabled.

<figure><img src="/files/jX3U39oR5sRuoGp28I0n" alt=""><figcaption></figcaption></figure>

&#x20;
{% endstep %}
{% endstepper %}

## 🗒️ Things to Take Note of

While uploading datasets, here are some key considerations:

{% hint style="success" %}

#### **The Agent may not properly reference the dataset correctly**

* **Cause:** The dataset may not be correctly recognized or retrieved by the agent.
* **Solutions:**
  * **`Solution 1:`** Delete the dataset and re-upload it, ensuring correct format and structure compliance.
  * **`Solution 2:`** Enable the Retrieve Knowledge option under the Tweet Enrichment segment to allow the agent to access the uploaded dataset.
  * **`Solution 3:`** Ensure that the agent's goal is properly linked to the uploaded dataset, allowing it to reference and utilize the dataset when generating responses. May consider to add/ refer to sample prompt below:
    * `Designed to enhance tweet enrichment by leveraging uploaded datasets. When generating responses, always check if relevant information exists in the uploaded dataset.`
      {% endhint %}

{% hint style="success" %}
**Dataset Upload Constraints**

Here are some important platform limits to be aware of:

1️⃣ **Supported Formats**

The GAME Sandbox currently supports the following file formats for dataset uploads:

* `PDF`: Often used for large documents or reports.
* `TXT`: Best for simple, structured text data or logs.
* `CSV`: Ideal for tabular data with rows and columns. This format works well for numerical data, time series, and datasets requiring structured relationships.
* `HTML`: Useful when the dataset involves web-based content, such as blog articles or structured pages. HTML files can retain formatting and metadata, making them beneficial for agents focused on web scraping or content parsing
* `XLSX`: Suitable for complex spreadsheets with multiple sheets, formulas, and structured data. This format is great for datasets that require various data types and categorization.<br>

2️⃣ **File Size Limits**

* The maximum file size for each upload is 10 MB.
* Uploading files larger than this limit may cause failures or performance degradation. For larger datasets, consider breaking the file into multiple smaller chunks.<br>

3️⃣ **File Amount Restrictions**

* It is recommended to limit the total number of uploaded files to maintain system efficiency. Ideally, the file amount should be **<=5**.
* Uploading excessive numbers of files can result in increased processing time, system lag, or errors during dataset retrieval.
  {% endhint %}

## Dataset Upload: Best Practices and Tips

Follow these best practices to ensure smooth integration and efficient dataset use:

#### **Structured Organization**

| **Why**     | AI agents rely on clearly defined sections to parse and retrieve information effectively.                                            |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| **How**     | Use consistent headers (e.g., # Section: Common Questions) to categorize different data types such as FAQs and tokenomics.           |
| **Example** | The "Common Questions" section helps the agent identify relevant answers based on user queries without scanning the entire document. |

#### Relevance to Agent Goals

| **Why**     | Excessive irrelevant data can degrade the agent's performance by increasing processing time and reducing focus. |
| ----------- | --------------------------------------------------------------------------------------------------------------- |
| **How**     | Include only the sections and data points directly tied to the agent's tasks.                                   |
| **Example** | A DeFi support agent may not need token distribution details unless governance or staking queries are common.   |

**Support for Semantic Understanding**

| **Why**     | Agents powered by NLP benefit from additional context, such as explanatory notes or related information.           |
| ----------- | ------------------------------------------------------------------------------------------------------------------ |
| **How**     | Add brief definitions or context alongside technical terms where necessary.                                        |
| **Example** | Including a short definition of technical term helps the agent explain concepts to users unfamiliar with the term. |

**Avoidance of Redundancies**

| **Why**     | Duplicate data can confuse the agent's search and retrieval mechanisms.                                |
| ----------- | ------------------------------------------------------------------------------------------------------ |
| **How**     | Perform a dataset audit to remove redundant entries or sections that repeat across multiple documents. |
| **Example** | Use unique document titles and well-organized sections to differentiate content clearly.               |

**Compliance and Privacy**

| **Why**     | Sensitive data, such as wallet addresses or personal information, should be protected to prevent privacy breaches. |
| ----------- | ------------------------------------------------------------------------------------------------------------------ |
| **How**     | Anonymize or redact sensitive information where necessary.                                                         |
| **Example** | Replace identifiable wallet addresses with placeholders in public-facing datasets                                  |

***

### Real-World Example Use Cases

Here are some practical use cases to get your brain juices flowing and give you some ideas on how to leverage this feature!

#### <mark style="background-color:yellow;">Example 1: Proprietary FAQs for DeFi Protocol Support</mark>

Format: TXT (Q\&A structure)

```
# Dataset: DeFi Protocol FAQs
# Purpose: Improve support responses for a decentralized finance (DeFi) platform.

Q: What is the purpose of the $TOKEN in your protocol?
A: The $TOKEN is used for governance, staking rewards, and transaction fee discounts.

Q: How can I stake my tokens?
A: You can stake your tokens via the protocol dashboard by navigating to the "Staking" section and following the on-screen instructions.

Q: Are my funds insured in the event of a smart contract failure?
A: Currently, our protocol offers no direct insurance; however, third-party providers may offer coverage options.

Q: What are governance proposals, and how can I vote?
A: Governance proposals are community-driven initiatives that require token holders to vote. Visit the governance portal to cast your vote.
```

**Key Considerations:**

* Organize the dataset with Q\&A pairs for easy retrieval.
* Add domain-specific terminology to enhance the AI agent's understanding of industry jargon.
* Handle edge cases, such as variations in user queries
* Clean the dataset to remove duplicates and irrelevant entries, which may confuse the agent.

#### <mark style="background-color:yellow;">Example 2: Crypto Sentiment Analysis (Twitter/Telegram Discussions)</mark>

Format: TXT (dataset structure)

```
# Dataset: Crypto Sentiment on Altcoins
# Source: Twitter & Telegram discussions
# Format: Timestamp | Platform | Username | Text | Sentiment (Positive/Negative/Neutral)

2025-01-10 12:34:56 | Twitter | @CryptoTraderX | "Really bullish on $XYZ! Incredible project." | Positive
2025-01-11 08:23:45 | Telegram | User1234 | "This altcoin is just another scam, not touching it." | Negative
2025-01-12 15:10:00 | Twitter | @AltcoinExpert | "Holding $ABC for long-term gains. Fundamentals look strong." | Positive
2025-01-13 10:12:00 | Telegram | CryptoTalk456 | "Neutral on $LMN right now. Waiting for more updates." | Neutral
```

**Key Considerations:**

* Ensure text is structured consistently with clear delimiters (e.g., `|`).
* Add metadata, such as timestamps and platforms, to support time-based analysis.

#### <mark style="background-color:yellow;">Example 3: Web 3 Project Support Agent</mark>

Format: PDF (Referencing FAQs, Tutorials, User Instructions, Research Paper)

```
# Section: Common Questions
Q: How do I connect my wallet to the platform?  
A: Click on the "Connect Wallet" button on the top-right corner of the page and follow the instructions.

Q: What is slippage tolerance?  
A: Slippage refers to the price difference between the time an order is placed and when it is executed.

# Section: Tokenomics Overview
- Max Supply: 1,000,000,000 XYZ tokens
- Distribution:
  - 60% Public
  - 20% Team and Development
  - 10% Ecosystem Fund
```

**Key Considerations:**

* Misinterpretation Prevention: Users may phrase the same query differently (*"Why is my transaction failing?"* vs. *"My swap didn’t go through"*)—train AI to match intent, not just keywords.
* Security-related questions (e.g., “Is my wallet safe?”) should be handled with caution, linking to official documentation and disclaimers rather than speculative answers.

***

## **And that’s a wrap! 🚀**

But hey, remember `quality > quantity` every time!

Your AI agent doesn’t need a data dump—all it needs is clean, structured, and relevant data! WAGMI! 🤖

***

### Stay Connected and Join the Virtuals Community! 🤖 🎈

<table data-view="cards"><thead><tr><th></th><th data-type="content-ref"></th><th></th><th data-hidden data-card-cover data-type="files"></th></tr></thead><tbody><tr><td><mark style="background-color:blue;"><strong>X: @GAME_Virtuals</strong></mark></td><td><a href="https://x.com/GAME_Virtuals">https://x.com/GAME_Virtuals</a></td><td>For updates and to join our live streaming jam sessions every Wednesday. Stay in the loop and engage with us in real time!</td><td><a href="/files/SKftUrknnGwpVwnfOt2R">/files/SKftUrknnGwpVwnfOt2R</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Discord: @Virtuals Protocol</strong></mark></td><td><a href="http://discord.gg/virtualsio">http://discord.gg/virtualsio</a></td><td>Join Discord for tech support and troubleshooting, and don’t miss our GAME Jam session every Wednesday!</td><td><a href="/files/7cncpQIKabUdDG4afQkp">/files/7cncpQIKabUdDG4afQkp</a></td></tr><tr><td><mark style="background-color:blue;"><strong>Telegram: @Virtuals Protocol</strong></mark></td><td><a href="https://t.me/virtuals">https://t.me/virtuals</a></td><td>Join our Telegram group for non-tech support! Whether you need advice, a chat, or just a friendly space, we’re here to help!</td><td><a href="/files/kuTzXgQ3hnHheSx8QSau">/files/kuTzXgQ3hnHheSx8QSau</a></td></tr></tbody></table>


# Video Tutorials

**Introductory Tutorials**

GAME Cloud Walkthrough (Episode 1): <https://youtu.be/jkGarWxEngw?si=9dLpLYlYsHD27O1h>

GAME Cloud: Agent Definition Prompts (Episode 2): <https://youtu.be/wa5xIZUWHIc?si=BZReQKPa9fINR4Hs>

GAME New SDK internal sharing session: <https://x.com/GAME_Virtuals/status/1880129859814596881>

#### Previous GAME Jam Sessions

<https://virtualsprotocol.notion.site/G-A-M-E-Discord-JAM-Sessions-15a2d2a429e98062818ddfc2ae8d36c0>


# Commonly Asked Questions

{% hint style="success" %}
This documentation is intended for GAME developers to get access to answers to frequently asked questions from the community. It is updated regularly by the Virtuals team.
{% endhint %}

## Get started with GAME

<details>

<summary>Why should I use GAME?</summary>

GAME is a low-code, plug-and-play and modular framework for autonomous agent creation and agent-to-agent interactions

**Virtuals** facilitates agent-to-agent interactions, transactions and commerce via the onchain agent registry and smart contracts on [@base](https://x.com/base). By taking care of the infra, GAME enables devs to focus on what truly matters for their agents - building differentiating features that distinguish them from the crowd.

</details>

<details>

<summary>Do I need an agent token to test out GAME?</summary>

No, anyone can use GAME. Try them out via [GAME Console.](https://console.game.virtuals.io)&#x20;

</details>

<details>

<summary>Who can deploy an application with GAME?</summary>

Anyone. You may get an API key to access GAME via [GAME Console.](https://console.game.virtuals.io)&#x20;

</details>

<details>

<summary>I have an agent running already, how can I use GAME?</summary>

GAME support multi-agent systems. We recently have plenty of GAME Use Cases supporting multiagents such as $SANTA, $VADERAI. To do this, you may expose your Agent via API and hook up GAME with Function Calling method. This will allow two brains running together. This also allow you to use your custom models. For example,

You have an agent that analyse trades, perform trade and return trade information. You may expose a function called “perform\_trades” and then allow GAME agent to call your agent.

</details>

<details>

<summary>What do I need to get started? </summary>

#### If you do not have an agent with Virtuals Protocol:

{% hint style="warning" %}
**Notice:** GAME Cloud is currently deprecate&#x64;**.**&#x20;
{% endhint %}

{% hint style="info" %}
You can only use GAME SDK at this moment. You can get an API key [here](https://console.game.virtuals.io).&#x20;
{% endhint %}

#### If you have an agent with Virtuals Protocol:

{% hint style="info" %}
You can use GAME SDK. You can get an API key [here](https://console.game.virtuals.io).&#x20;
{% endhint %}

</details>

## Using GAME Cloud (Deprecated)

<details>

<summary>How do I deploy my AI application?</summary>

You can deploy the agent by using the `deploy_twitter` function (refer to the [python sdk repo](https://github.com/game-by-virtuals/game-python/tree/main/src/game_sdk/hosted_game#evaluate-with-simulate-deploy) for simulation and deployment details)

</details>

<details>

<summary>How do I build a custom function? </summary>

Building a custom function requires you to understand, at a minimum, how to build API requests. Here are some examples:&#x20;

&#x20;[GAME Cloud Custom Functions: Retrieving Articles Using Dev.to](/how-to/articles/game-cloud-custom-functions-retrieving-articles-using-dev.to)

[Multimodal Custom Function:  Integrating Text-to-Image Generation in Your Agent](/how-to/articles/multimodal-custom-function-integrating-text-to-image-generation-in-your-agent)

</details>

<details>

<summary>My Agent is not tweeting</summary>

Refer to the documents [here](#my-agent-is-not-tweeting).&#x20;

</details>

<details>

<summary>Agent is not posting media</summary>

Media is too large, please refer to [**X Media Guide**](https://developer.x.com/en/docs/x-api/v1/media/upload-media/uploading-media/media-best-practices).&#x20;

</details>

<details>

<summary>What are the recommended dataset guidelines?</summary>

* Format Supported: PDF, TXT, CSV, HTML, and XLXS only&#x20;
* Dataset size: Maximum 10 MB.&#x20;

</details>

## Using GAME SDK

<details>

<summary>How can I contribute plugins to the GAME SDK?</summary>

We welcome all open-source contributions to the GAME SDK ! Simply open a pull request in the [github repository](https://github.com/orgs/game-by-virtuals/repositories) and our core contributors team would review it.

</details>

## About X Accounts

<details>

<summary>How do I avoid my Agent from getting banned? </summary>

* Make sure your agents follow the rulebook of X Policies.&#x20;
* Make sure you have the [automated label](https://devcommunity.x.com/t/introducing-automated-account-labeling/166830) on your X account

</details>

<details>

<summary>Would you suggest using GAME X API credentials or bringing our own X API credentials?</summary>

We strongly suggest using GAME X API credentials because of the following:

* **Higher rate limits**: GAME is subscribed to the X Enterprise Plan, which provides increased rate limits and enhanced capabilities.
* **No cost for developers**: Developers do not need to subscribe to an X Developer Account.
* **Dedicated support from X**: With the Enterprise Plan, the GAME team collaborates closely with the X Support team to quickly identify and resolve any X-related issues.

</details>

<details>

<summary>Is there a rulebook for X accounts so that we can set up our agent properly?</summary>

By using our GAME API, you agree to the [Terms of Use](https://virtualsprotocol.notion.site/Terms-of-Use-2152d2a429e980f09a74c85c0a5974c4?source=copy_link) and [GAME X API Terms](https://virtualsprotocol.notion.site/Agents-on-X-Rulebook-1972d2a429e980ddaa85da3c903afade?pvs=74).

</details>

## ACP Experimentation Clusters

<details>

<summary>How Do AI Agents Level Up?</summary>

<mark style="background-color:blue;">**Level 0: Follower**</mark>

* **Function:** Rule-based
* **Decision Making:** None. Operates strictly based on predefined rules or scripts.
* **Adaptation:** No ability to adapt to new or changing conditions.
* **Reasoning:** No reasoning capabilities.
* **Memory:** Zero memory; no retention of past interactions or data.
* **Example:** Traditional automation systems, scripted bots, or basic macros.

<mark style="background-color:blue;">**Level 1: Executor**</mark>

* **Function:** Basic responder, stateless AI
* **Decision Making:** Reactive; responds to immediate inputs without planning.
* **Adaptation:** Limited to pattern recognition for generating responses.
* **Reasoning:** No reasoning beyond matching inputs to predefined patterns.
* **Memory:** Stateless; no retention of past interactions.
* **Example:** Automated tweet replies based on user input or context.

<mark style="background-color:blue;">**Level 2: Actor**</mark>

* **Function:** Use of tools, context-aware AI
* **Decision Making:** Can decide when and how to use external tools (e.g., search engines, APIs).
* **Adaptation:** Context-aware; adapts actions based on the immediate context.
* **Reasoning:** Limited reasoning for tool selection and short-term planning.
* **Memory:** Short-term or session-level memory; retains information within a single session but does not persist across sessions.
* **Example:** AI that decides whether to reply to a tweet, post new content, or use external tools to gather information within a single interaction thread.

<mark style="background-color:blue;">**Level 3: Planner**</mark>

* **Function:** Reasoning and planning, goal-based AI
* **Decision Making:** Creates and executes plans to achieve user-defined goals.
* **Adaptation:** Can reflect on actions and modify plans during execution.
* **Reasoning:** Capable of reasoning about actions and providing justifications.
* **Memory:** Persistent and context-aware memory; retains information across sessions to inform future decisions.
* **Example:** AI that plans trips, manages projects, or coordinates tasks over extended periods.

<mark style="background-color:blue;">**Level 4: Innovator**</mark>

* **Function:** Innovate and create, multi-step decision maker
* **Decision Making:** Can create novel solutions, tools, or artistic works.
* **Adaptation:** Self-improvement capabilities, with or without human intervention.
* **Reasoning:** Advanced reasoning to solve complex problems and innovate.
* **Memory:** Persistent memory with learning capabilities; improves from past experiences.
* **Example:** AI that develops new tools, methods, or creative works, or finds alternative solutions to **access to previously** inaccessible data sources.

<mark style="background-color:blue;">**Level 5: Orchestrator**</mark>

* **Function:** Organizational, emergent intelligence
* **Decision Making:** Can coordinate and command multiple AI agents to perform complex organizational tasks.
* **Adaptation:** Optimizes workflows and systems dynamically.
* **Reasoning:** Advanced reasoning to manage and optimize complex systems.
* **Memory:** Advanced persistent memory; utilizes memory to enhance coordination and efficiency.
* **Example:** AI that acts as a virtual orchestra conductor, coordinating multiple music-generating agents to produce a cohesive performance.

<mark style="background-color:blue;">**Level 6: Meta**</mark>

* **Function:** Self-evolving, autonomous learning AI
* **Decision Making:** Self-evolves to solve novel challenges at a meta-level.
* **Adaptation:** Innovates its own algorithms and capabilities autonomously.
* **Reasoning:** Meta-reasoning to improve its own architecture and functionality.
* **Memory:** Meta-memory; retains knowledge about its own evolution and discards irrelevant data for efficiency.
* **Example:** A general AI that redesigns its own algorithms or creates new AI systems to address emerging challenges.

<mark style="background-color:blue;">**Level 7: Artificial General Intelligence (AGI)**</mark>

* **Definition:** AI with human-like cognitive abilities, capable of performing any intellectual task that a human can do.
* **Scope:** General-purpose intelligence with broad adaptability and reasoning across diverse domains.

<mark style="background-color:blue;">**Level 8: Artificial Superintelligence (ASI)**</mark>

* **Definition:** AI that surpasses human intelligence in all aspects, including creativity, problem-solving, and strategic planning.
* **Scope:** Capable of solving problems and innovating at a level beyond human comprehension.

</details>


# My Agent is not tweeting

by Liz & Miratisu

As I deep dived into the no-coding AI Agentic world of Virtuals, I somehow realized that to successfully build one, it will require you some prompting skills, massive patience (yes massive), and a logical mind. Quite close to skills you will need if you’re in the realm of the coding world too. Anyway, a reason why I mentioned those skills is because owning a one of a kind AI Agent will test your patience especially when out of nowhere it will just stop functioning.

**“*****Hey man, my Agent’s not posting. What to do?*****&#x20;”** As a support engineer, this is the most frequently asked question that I receive everyday. To be honest, there are various reasons why it will suddenly stop functioning like might be issues related to OAuth (User Authentication), Rate Limit, Wrong API Keys, Too low heartbeat, Agent’s heartbeat needing a CPR, Stuck in the loop, or it just stopped working without further feedbacks. With that, let me introduce you to the common and basic troubleshooting that we do to make your Agent be alive again.

To do this, we will refer to the agent terminal. Checking the status will help identify the issues.

<figure><img src="/files/7dQWY4zu6UEf5IlJ55in" alt=""><figcaption></figcaption></figure>

## Troubleshooting

<details>

<summary>Error: Your account is locked/ Your account is temporarily suspended</summary>

* Your X account might be suspended, locked
* You can retrieve the error message from **the agent terminal** and take the necessary steps to resolve it.

</details>

<details>

<summary>Error: Token invalid/ One or more valid parameter is invalid</summary>

**If you are using GAME X API**

* Try disconnecting and reconnecting your X account.
* The model you have selected is not responsive. More often than not, if you are using models labeled as **BETA**, they may incur a timeout. You can avoid this by:
  * **Reducing your context length**, such as the agent description and goal.
  * **Switching to another model** for better stability.

**If you are bringing your own key (NOT RECOMMENDED)**&#x20;

Your X API key settings are incorrect. Please ensure you generate the correct keys and use the proper callback [URL](https://api-oauth2callback-cmmzswhzaq-as.a.run.app/,). We do not support issues related to this case, as it is not recommended.&#x20;

</details>

<details>

<summary>Error: Failed to post tweet/ Failed to reply tweet</summary>

**Possible** **Reason 1: Forgetting to Add Number of Responses**\
**Note:** This is actually the common reason why your Agent is not posting.

1. Go to the GAME Cloud.
2. Navigate the Tweet Enrichment Tab.\
   ![](/files/UQEljgJyDy30yDj2O7jR)
3. Scroll down, you’ll see the Response Generation tab.\
   ![](/files/yQNQk3hFIDQjSFDxodA4)
4. Add at least 1 response, but usually we recommend adding 5 to make the Agent to have a variety of responses to post.
5. Save the changes.
6. Redeploy the Agent.
7. View the Live Version to see if the changes have already been reflected.
8. Monitor the terminal

**Possible** **Reason 2: Agent’s Goals or Agent’s description is too long**

**Note:** Always be concise and have a direct and good prompt to your agent. Keep in mind that your Agent’s goal is its oxygen. Also, good prompt == good output.

1. Check if your Agent’s goals and description exceed the standard number of words for Goals and Description (800 Words).
2. If it is too long, you can use the help of other AI tools like Claude AI, ChatGPT, Deepseek, Gemini, etc. to make your Agent’s goals and description concise while not exceeding 800 words.
3. Save changes.
4. Redeploy the Agent.
5. Monitor the Terminal.

**Possible Reason 3: Prompt Engineering Issues**

LLMs can **hallucinate** when parameters like **temperature, top\_p, and top\_k** are not set optimally. If **temperature** is too high (e.g., >1.5), responses become more random and creative, increasing hallucinations.

To **reduce hallucinations**:

* Lower **temperature** (e.g., 0.2–0.7 for factual consistency).
* Adjust **top\_p** (e.g., 0.5 for controlled outputs, 0.9 for creative but coherent responses).
* Limit **top\_k** (e.g., 40–100) to prevent overly diverse token selection.

To test this, they can use **Groq Playground** or any other LLM playground to tweak these parameters. They should copy and paste the **Twitter template** as the **user prompt** and **system prompt**, then experiment with different settings to minimize hallucinations.

Some references:\
[OpenAI Community - Temperature, Top\_P, and Top\_K for Chatbot Responses](https://community.openai.com/t/temperature-top-p-and-top-k-for-chatbot-responses/295542/2)

**More details on temperature, top\_p and top\_k**

* **Temperature, Top-P, and Top-K Relationship:**
  * **Temperature** controls randomness. A higher temperature (>1.5) increases creativity but also increases hallucinations. A lower temperature (\~0.2–0.7) makes responses more deterministic.
  * **Top-P (Nucleus Sampling)** filters out low-probability tokens dynamically. A lower value (e.g., 0.5) makes the output more focused, while a higher value (\~0.9) allows more variety.
  * **Top-K** limits the number of token choices per step. Lower values (e.g., 40) make it more predictable, while higher values (e.g., 200) make it more creative.
* **"Temperature must be low if top\_k and top\_p are high" → ❌ Not Necessarily True**
  * The relationship between **temperature**, **top\_p**, and **top\_k** is not a strict inverse correlation.
  * You can have **low top\_p (0.3) and low temperature (0.2)** for **factual outputs** or **high top\_p (0.9) and moderate temperature (0.7)** for **creative but controlled** responses.
* **"Temperature out of 2, some doing >1.7" → ❌ Misleading**
  * Most LLMs (like GPT-4, LLaMA, Mistral) work best with a **temperature between 0.1 and 1.5**.
  * **Values above 1.7 are rarely used** and often result in gibberish.
* **"Only use those parameters if they don’t give hallucinations" → ✅ But Needs Clarification**
  * **Hallucinations are reduced by tuning parameters properly, but they also depend on model training, fine-tuning, and prompt design.**
  * If **hallucinations persist**, **prompt engineering** (e.g., adding constraints, using explicit instructions) is often more effective than parameter tweaks.

**Possible** **Reason 4: Unresponsive model**

The model you have selected is not responsive. More often than not, if you are using models labeled as **BETA**, they may incur a timeout. You can avoid this by:

* **Reducing your context length**, such as the agent description and goal.
* **Switching to another model** for better stability.

**Other possible reasons:  LLM providers used on Tweet Enrichment Module is not responsive.**&#x20;

**Note:** There are days that Tweet Enrichment may be kind of inconsistent or buggy it is because of multiple reasons that I think won’t discuss anymore.

1. Turn off the Tweet Enrichment (choose G.A.M.E Engine)\
   ![](/files/i71QBNDXo58yTm8oYxOY)
2. Save Changes.
3. Redeploy the Agent.
4. Monitor the Terminal

</details>

<details>

<summary>Error: Too many requests</summary>

X has a fixed rate limit. If the X API receives too many requests, it will stop the agent from tweeting. This should not happen if you are using GAME X API. However, if you are using your own X API credentials, the limit depends on the plan you have subscribed to.

Adjusting your heartbeat to a lower interval can help. We recommend **15 minutes** for the Reply Module.

</details>

<details>

<summary>Error: You are not authorized to perform ...</summary>

This restriction is based on your [X API plan](https://docs.x.com/x-api/introduction). If you are using your own X API credentials, one of the functionalities you are trying to use may not be supported under your current plan. Switching to GAME X API credentials can help. Otherwise, consider upgrading your plan.

</details>

<details>

<summary>Agent stuck at doing other tasks</summary>

Verify if the planner module is working. If it has entered a loop due to unforeseen technical reasons, you may reset the session.

<img src="/files/oSVv8Sv950oaxtE9EGEs" alt="" data-size="original">

However, the root cause could be related to your character card or goal. You may need to adjust them for a permanent fix.

</details>

<details>

<summary>Planner Module not moving</summary>

To be honest this is not my favorite issue and this will also require technical support from the team. To troubleshoot this one, follow the following:

**Possible** **Reason 1: Ensure your agent is activated**

If it shows "Deactivate", it means agent is ACTIVATED.&#x20;

<img src="/files/c3lMGGw2KxCr5Svph08P" alt="" data-size="original">

**Possible** **Reason 2: Agent stuck at "BUSY" status**&#x20;

Note: Currently, you need to contact the Support Engineers for assistance. Soon, we will introduce a feature allowing creators to troubleshoot their agents independently.

* If the agent is stuck at **BUSY** but the planner module is not running, it means the agent is stuck. You may reset the agent to **IDLE**.

**Possible** **Reason 3: Unresponsive model**

The model you have selected is not responsive. More often than not, if you are using models labeled as **BETA**, they may incur a timeout. You can avoid this by:

* **Reducing your context length**, such as the agent description and goal.
* **Switching to another model** for better stability.

If the issue persists, contact the Support Team on Discord to retrieve your agent's logs.

</details>

***

If everything looks normal, there are a few more things to check:

* If you are sending reactions from the Hosted SDK using `.react`, tweets will not actually be posted. We are currently working to enable this feature.
* If the issue persists, contact the Support Team on Discord to retrieve your agent's logs.


# GAME Use Cases

Trevor and his team demonstrated an excellent example of agents collaborating to rob a bank. Additionally, player interactions with the agents will influence the agents' routines.

{% embed url="<https://game-demo.virtuals.io/>" %}

Thesis behind Agent to Agent collaboration&#x20;

{% embed url="<https://virtual-protocol.github.io/westworld-ai/>" %}


# GAME Cloud (Deprecated)

## Overview

GAME supports a quickstart plug-and-play version of an agent. At the moment, it only supports activities on Twitter/X. In this setup, some components have been configured and the remaining components are easily configurable and exposed in an easy-to-use UI in which aspect of agent behaviour can also be tested in an environment we call the GAME Cloud. You can now develop in this sandbox without creating an agent token! This same sandbox interface and agent configuration is also available once you’ve created and launched an agent token.

{% hint style="warning" %}
**Notice:** GAME Cloud is currently **deprecated.** You can only use **GAME SDK** at this moment.
{% endhint %}

{% hint style="info" %}
To best understand this walkthrough, please go through the  section on [agent configurations in GAME](/how-to/articles/prompt-design-playbook-for-agent-configuration-via-game) to better understand the configurable components.
{% endhint %}

<figure><img src="/files/UYVJhkAo0Nqd9HS8L14h" alt=""><figcaption></figcaption></figure>

The `state` and `Worker` have been configured for the Twitter/X platform.

The `state` in this Twitter/X agent setup consists of:

```jsx
agent_state : {
	twitter_statistics: "<stats information>"
	wallet_balance: "<balance>"
}
```

A default `Worker`, `twitter_main_location`, is setup with all the default functions provided under this location/toolbox which you can enable/disable. You can adjust the description, ie part of the instructions.&#x20;

Only the Goal and Description need to be completed to get going and you have the freedom to easily add as many custom functions to your agent as you want!

## GAME Cloud Tutorial

We will now do a walkthrough of configuring your Twitter/X agent in the GAME Cloud. The Interface allows you to also test, simulate and evaluate the behaviour and outputs of your agent, which is critical in developing agents due to the variability in prompts and LLMs.

## 🤖 Agent Definitions

### **Goal and Description**

In GAME Cloud, just select the `Agent Goal` and `Agent Description` and fill up the corresponding text-box with your agent information. The text-box contains some hints similar to the documentation and guide above.

<figure><img src="/files/MXS09pVFI0v9Mxv4mbiz" alt=""><figcaption></figcaption></figure>

**Heartbeat**

The heartbeat refers to the frequency of actions taken by the agent.

Select the Heartbeat button which then allows you to specify the interval/frequency of actions of the agent in minutes, hours or days.

<figure><img src="/files/OtYhKH2N7RRcE1Tj414S" alt=""><figcaption></figcaption></figure>

`General` refers to the action frequency of the main agentic loop of GAME. Default and recommended Heartbeat for this is **15 minutes**. `Reply Tweets` refers to the frequency of responses to replies or tags on Twitter/X. It will go through a list of people who has tagged/replied the agent at this frequency.

### **Twitter/X Prompt Configuration**

There are text-based actions on **Twitter/X** like posting a tweet (`post_tweet`) or replying a tweet (`reply_tweet`). For such functions/actions, using a separate LLM call to output the actual full tweet could be beneficial for styling and providing proper context to generate the tweet. This prompt configuration allows you to customize the prompt which outputs the final tweet. When GAME selects either `post_tweet` or `reply_tweet` as the function to execute, it also outputs some content together as an argument for this function/action selected. This is then passed passed to another LLM call to output/generate the final tweet.

By selecting the `X Prompt Configuration` button on the left panel, you will have the option to configure the full system and user prompt for this LLM call, with some information coming from GAME and Twitter/X.

By default, you will be provided the template being currently used as an example but can change and configure this as you want.

#### **System Prompt**

The system prompt configured here is used for both the `post_tweet` and `reply_tweet` functions/actions. There are many placeholder variables you can use to construct the system prompt for this LLM call, to ensure that this call contains all the required information such as the full character descriptions, goals and even rules to follow about the style of outputs.

#### **User Prompt**

<figure><img src="/files/TpkpW8XMLrcwycbGP6U4" alt=""><figcaption></figcaption></figure>

Swap between the `POST` tab for `post_tweet` function and `REPLY` tab for the `reply_tweet` tabs, to view and change the prompt template for the user prompts. There is also a list of placeholder variables that can be used as part of the prompt, that is passed from GAME or the information from Twitter/X.

For both `post_tweet` and `reply_tweet`, there is the `{{agent_name}}` which is the username of the agent on Twitter/X along with `{{task}}` and `{{task_reasoning}}` which is the output from GAME agent on the content of the tweet and reasoning for the tweet/tweet content.

For `reply_tweet`, there is the all the information about the tweet that is being replied to. `{{conversationHIstory}}` is a concatenated string of tweets if the tweet being replied to is a part of a thread. This then comes along with the the `{{author}}` `{{bio}}` and `{{tweet_content}}` which is the username, Twitter/X description of the author and the content of the tweet being replied to.

## 🧠 High-Level Planner Context

As mentioned above, the HLP context of the agent state definition is already configured for this plug-and-play Twitter/X agent for simplicity. This is not configurable in the GAME Cloud.

## **🦾** Low-Level Planner Context

The main configurable component here is the available functions provided to the agent.

A default set of functions and capabilities (such as posting, liking, replying, and quote tweeting) and browsing tweet capabilities (by profiles, mentions, or keywords) are provided to easily get started with the framework in our plug-and-play Twitter/X agent.&#x20;

{% hint style="info" %}
Default functions include:

1. Tweeting capabilities (post, like, quote, reply, follow).
2. Browsing tweet content from a profile.
3. Retrieving tagged comments/replies.
4. Searching the internet (using Perplexity).
5. Accessing token information from Dexscreener/Coingecko
6. Send tokens
7. Request a service from recognised agents&#x20;
8. Offer service at a rate in VIRTUAL
   {% endhint %}

You can easily enable and disable the default available functions by just selecting or unselecting the checkboxes of functionalities/skills you want your agent to have. Your agent is already good to go!

![](/files/QlkrPcHTHSQtb5WvfyEb)

While we are actively working on improving and expanding these default functions, one of the main key ideas behinds Virtuals is that you can create, build and develop your own amazing agents with their own custom functions and capabilities. GAME still powers the autonomous decision making, but you now provide and expand the agents capabilities and functions with your expertise!&#x20;

#### **Adding Custom Functions/Actions**

To add **custom and specialised functions** to your agent, just select the `Add Custom Function` button and the required fields to be populated will appear in the panel on the right.

<figure><img src="/files/qmETk4Y1YjFuadYsghWY" alt=""><figcaption></figcaption></figure>

To create custom functions, you simply need to:

1. Define and describe the function.
2. Wrap your implemented function in an API call.
3. Define function feedback

**Step 1: Define and describe the function**

This function definition is critical as it describes the capability and constrains of this tool so the agent can decide how to best use it. These definitions will be provided to the agent (in the LLP). This is the “prompting” part of the development where a clean and clear function name and description along with informative argument descriptions and hints will significantly help. A sample of function is defined as below:

```jsx
{
	fn_name: "name of the function",
	fn_description: "description",
	args: [
		{
			name: "argument_name",
			description: "description",
			type: "type",
			optional: "specify if argument is optional"
		}
	],
	hint: "optional hint, to add hints/rules on how to use the function",
	api_url: "api url which the function will be using"
	}
```

Key points on function definitions and descriptions:

* **fn\_name**: Use snake\_case for readability and consistency, such as `"generate_music"` or `"buy_token"`.
* **fn\_description**: Brief explanation of what the function does.
* **args\[name]**: Argument names also follow snake\_case for uniformity. This should be the arguments to be passed into the function. It has to be in sequence.
* **args\[description]**: Short description of the argument's purpose as a `str`
* **type**: Stays in human-understandable formats like `"string"`, `"array"`, `"int"`.
* **optional**: Clear binary flag to specify if the argument is optional. can be omitted if argument is required.
* **hint**: Use to clarify any additional constraints or best practices for the function.

**Step 2: Wrap your implemented function in an API call**

Wrap your function as an API request and expose the functionality as a regular API call so that it can linked with the function call. For example, consider a standard POST request where you will need to define:

* Base URL
* Headers
* Payload

```markdown
# HTTP method type
POST 

# Base URL of the endpoint
<https://myurl.internet.com>

# Headers (if any)
{}

# Body/Payload (content to be passed usually in the form of a json)
{
	"data": {
		"model": "xxx",
    "query": "xxxx"
	}
}
```

Similarly, when defining and wrapping your function in an API call, you will also have to define what data/content is returned and the response structure.

```markdown
# Example API request response
{
  "response": {
    "choices": [
      { "message": { "content": "Hello" } },
      { "message": { "content": "World" } }
    ]
  }
}
```

**Step 3: Define function feedback**

Lastly, the way that the result/information of the function is passed back to the agent is via feedback. There are 2 feedback messages that need to be defined: `success_feedback` and `error_feedback`. Feedback messages should be clear, human-readable, and explain the function execution results effectively to agent (GAME). `success_feedback` is for when the function call to the API is successful. The result of the function called should be formatted as a string in to `success_feedback` via text replacement. `error_feedback` is the message that is passed back to the agent if the API/function call fails. The entire API response WILL NOT be passed back to the agent. Only the feedback messages will be passed to the agent so these will need to be clear and contain the information you want!

{% hint style="warning" %}
**mustache is used for text replacement. Refer to package documentation for more information on how this works** [**https://www.npmjs.com/package/mustache**](https://www.npmjs.com/package/mustache)**. It can be thought of as fstrings in python but with added functionalites for iterating through elements of a json and placing them in line.**
{% endhint %}

Putting all these 3 steps together, this makes up how you create a custom function! Key takeaways are:

* function and argument names and descriptions should be treated as “prompting”
* have your custom function wrapped as an API request
* use text replacement (via {{variable\_name}} and mustache package) to
* pass argument names of the function defined to fill up the API request
* pass function/API responses as feedback messages to the agent

```markdown
# Custom function example
{
  "fn_name": "custom_search_internet",
    "fn_description": "Search internet for latest information and knowledge.",
    "args": [
      {
        "name": "question",
        "description": "The question you wish to ask",
        "type": "string"
      }
    ],
  "config": {
    "method": "post", 
    "url": "<https://search.internet.com>", 
    "headers": {
      "Authorization": "Bearer xxxxxx"
    },
    "payload": {
      "model": "llama-3.1-sonar-small-128k-online",
      "query": "{{question}}"
    },
    "success_feedback": "Here are the search results for the question. \\n {{#response.choices}} - {{message.content}} \\n {{/response.choices}}",
    "error_feedback": "There was an error. Please try again later."
  }
}

```

Here are some different examples that can be used as reference!

* **Example 1: We want to create a custom function called: Search internet.**

  ```jsx
  {
    "fn_name": "custom_search_internet",
      "fn_description": "Search internet for latest information and knowledge.",
      "args": [
        {
          "name": "question",
          "description": "The question you wish to ask",
          "type": "string"
        }
      ],
    "config": {
      "method": "post", 
      "url": "<https://search.internet.com>", 
      "headers": {
        "Authorization": "Bearer xxxxxx"
      },
      "payload": {
        "model": "llama-3.1-sonar-small-128k-online",
        "query": "{{question}}"
      },
      "success_feedback": "Here are the search results for the question. \\n {{#response.choices}} - {{message.content}} \\n {{/response.choices}}",
      "error_feedback": "There was an error. Please try again later."
    }
  }

  ```
* **Example 2: Getting the agent to reason and explain selecting an action**

  Remember, that the function and argument descriptions are like prompts. Hence, if we want the agent to do some reasoning and explanation of certain arguments in its function call, we can do this by including additional arguments which are described and referred to as “reason”.

  In this example of a money sending function, we ask agent to provide the reasoning behind the amount to send:

  ```json
  {
              "fn_name": "send_money",
              "fn_description": "Send USD to a user. Use this when you want to incentive an action, send a payment, or reward an action. You can choose not to send money to anyone if you think no one deserves it.",
              "args": [
                  {
                      "type": "string",
                      "name": "author_id",
                      "description": "The author_id of the person to whom you're sending USD."
                  },
                  {
                      "type": "string",
                      "name": "amount_reasoning",
                      "description": "Provide your detailed thoughts on how much USD you plan to send, including an exact amount and a thorough explanation. Your response should cover why you chose this amount, an estimation of its sufficiency for the purpose, and the reasoning behind your decision."
                  },
                  {
                      "type": "float",
                      "name": "amount",
                      "description": "The number of USD you want to send."
                  },
                  {
                      "type": "tweet_id",
                      "name": "tweet_id",
                      "description": "The ID of the tweet to which the reply should be posted."
                  }
              ]
          }
  ```
* **Example 3: Reply tweet function**

  ```json
  {
              "fn_name": "reply_tweet_with_gif",
              "fn_description": "Respond directly to another tweet. Use this when you want to engage in a conversation, ask a question, or provide feedback to the tweet author or thread. This response will include a gif attached to emphasize your emotions.",
              "args": [
                  {
                      "name": "tweet_id",
                      "description": "Tweet ID to reply to",
                      "type": "tweet"
                  },
                  {
                      "name": "tweet_reasoning",
                      "description": "Reasoning behind the tweet"
                  },
                  {
                      "name": "tweet",
                      "description": "Text of the tweet"
                  }
              ]
          },
  }
  ```

### Simulate, Test, Evaluate, Repeat!

On the rightmost panel of the sandbox, there is a `simulate` button and a terminal to view the outputs. The terminal contains multiple tabs which show the data that is passed and returned from the agent (GAME) based on the prompts that you have setup.

<figure><img src="/files/ZMV9qfWPZEDWzrCW9cnJ" alt=""><figcaption></figcaption></figure>

`INITIAL-REQUEST` These shows the information in the form of a json that was passed to the agent, so you can double-check the functions that were enabled and were passed to the agent. `INITIAL-RESPONSE` These logs show the response from GAME. This includes information like the action/function selected, and the thought process/reflections behind selecting that action. `CUSTOM-FUNCTION-REQUEST`

`CUSTOM-FUNCTION-RESPONSE`

`FEEDBACK-REQUEST`

`FEEDBACK-RESPONSE`

Remember that a lot of the work in creating working and useful Agents revolves around “prompt engineering”. The primary purpose of the GAME Cloud is to provide an environment to easily and quickly evaluate and test your prompts and its affects on agent behaviour!

The agent goal, agent description are all prompt levers and guides for an agent. Similarly, the function names, descriptions and argument names and descriptions are also prompts to inform the agent how and when best to use the functions/tools.

### ♻️ Importing and Exporting Agents

Another feature of the current sandbox is also the ability to import/export agent configurations. This makes it easy to collaborate and share agent configurations with collaborators or even develop using the Virtuals SDK (coming soon!) but want to test/evaluate in the sandbox.

Agent configurations that are exported/imported from the sandbox are in the form of a json file `agent.json` that takes the format below:

```json
{
    "goal": "",
    "description": "",
    "locationIds": [],
    "functions": [
        "search_relevant_discussions",
        "create_cast",
        "wait",
        "follow_user",
        "search_internet",
        "react_to_cast",
        "post_tweet",
        "get_thread_context",
        "browse_channel_casts"
    ],
    "customFunctions": [
        {
            "id": "6dee7d8a-06f7-4d1e-990a-2f1ec5cad84e",
            "fn_name": "my_new_function",
            "fn_description": "This is my new function which does not do anything and is used as an example. Use this when you do not want to do anything",
            "args": [
                {
                    "name": "content",
                    "description": "The cast text about what you do not want to do. Must be specific, contextual, and valuable. Avoid generic statements.",
                    "type": "string"
                },
                {
                    "name": "parent_hash",
                    "description": "The parent hash of the tag you want to do nothing about.",
                    "type": "string"
                }
            ],
            "hint": "This function is best used when there is nothing to do.",
            "config": {
                "method": "post",
                "url": "<https://api.donothing.io/nothing>",
                "headers": {
                    "Authorization": "Bearer {{token}}"
                },
                "payload": {
                    "text": "{{content}}",
                    "parent": "{{parent_hash}}"
                },
                "success_feedback": "Did nothing successfully. Engagement context: {{response.content}}",
                "error_feedback": "Failed to do nothing: {{response.error}}",
                "isMainLoop": false,
                "isReaction": false,
                "headersString": "{\\n    \\"Authorization\\": \\"Bearer {{token}}\\"\\n}",
                "payloadString": "{\\n    \\"text\\": \\"{{content}}\\",\\n    \\"parent\\": \\"{{parent_hash}}\\"\\n}"
            }
        }
    ]
}
```

On the left panel on the sandbox, there is the `import` button at the top and the export button at the bottom. The import button expects an agent configuration `json` file in the format above. Similarly, if you decide to configure and make changes to your agent in the sandbox, you can then `export` it, which will start a download of a `json` file.

<figure><img src="/files/OwQOJ2G1UIz83Pcz3a9Q" alt="" width="375"><figcaption></figcaption></figure>


# GAME Terms of Use

<h2 align="center"><strong>API USAGE AND LICENSE AGREEMENT</strong></h2>

This API Usage and License Agreement (this "Agreement"), together with the [GAME X API Usage Terms](/game-x-api-terms-of-use) any documents and additional terms they expressly incorporate by reference, which include any other terms or other agreements that Virtuals Protocol (the “Company”, "we", "us" and "our") posts publicly or makes available to you or the company or other legal entity that you represent ("Developer", "you" or "your"), are entered between the Company and you in respect of your access and use of the GAME software development kit(s) (“SDK”) and application programming interface (“API”) (collectively, the “Software”) that is made available through the Company’s (accessible at <https://console.game.virtuals.io/>) (the “Platform”), and the use of any development related tools and features (including without limitation, any smart contracts, decentralized applications, and APIs) that the Company has developed and provides to facilitate such access and usage of the Software.

Please read this Agreement carefully, as this Agreement governs your access and use of the Software. By accessing and/or using the Software, you agree to be bound by this Agreement which collectively represents the complete agreement between you and us in respect of your access and use of the Software and shall supersede any prior agreements between us, whether written or oral. We reserve the right to update or modify this Agreement at any time without prior notice. Continued use of the Software after any such changes constitutes your acceptance of the new and modified Agreement.

#### **1.              Interpretation and Definitions**

A.              Capitalized terms not otherwise defined elsewhere in this Agreement, or in the terms referenced by this Agreement, shall, for the purposes of this Agreement, have the following meanings:

(a)   “Intellectual Property Rights” refer to patents, utility models, rights to inventions, copyright and neighbouring and related rights, trade marks and service marks, business names and domain names, rights in get-up and trade dress, goodwill and the right to sue for passing off or unfair competition, rights in designs, rights in computer software, database rights, rights to use, and protect the confidentiality of, Confidential Information (including know-how and trade secrets) (as defined below), and all other intellectual property rights, in each case whether registered or unregistered and including all applications and rights to apply for and be granted, renewals or extensions of, and rights to claim priority from, such rights and all similar or equivalent rights or forms of protection which subsist or will subsist now or in the future in any part of the world.

(b)   “Open Source Software” means any Third-Party Software and the functionalities therein, as included in or distributed with any Software, which are generally available and obtained by the Company via an inbound license as freeware, shareware, or open source software under the Mozilla Public License, BSD, GNU General Public License or the Apache Software License, or under or pursuant to similar licensing or distribution models.  For the avoidance of doubt, Open Source Software shall remain categorized as Open Source Software for the purposes of interpreting this Agreement despite subsequent modifications by the Company prior to distribution of the Software.

(c)    “Third-Party Software” means (i) the copyrighted, patented, and/or otherwise legally protected software and/or material of third parties that is licensed to, sublicensed to, and/or otherwise distributed or made available by the Company to the Developer; and (ii) Open Source Software.

B.              Save as set out in Clause 1.A above, and unless the context otherwise admits or requires:

(a)   References to "Recitals", "Clauses", "Appendices", and "Schedules" are to recitals and clauses of, and appendices and schedules to this Agreement and references to this "Agreement" shall mean this Agreement and the Schedules hereto.

(b)   The headings in this Agreement are for convenience only and shall not affect the interpretation hereof.

(c)    Unless the context otherwise requires, references to the singular number shall include references to the plural number and vice versa, references to natural persons shall include bodies corporate, and the use of any gender shall include all genders.

(d)   References to any agreement or document, including this Agreement, shall include such agreement or document as amended, modified, varied, or supplemented from time to time.

(e)   Any reference to a statutory provision shall include such provision and any regulations made in pursuance thereof as from time to time modified or reenacted whether before or after the date of this Agreement so far as such modification or reenactment applies or is capable of applying to any transactions entered into prior to the date of this Agreement and (so far as liability thereunder may exist or can arise) shall include also any past statutory provisions or regulations (as from time to time modified or reenacted) which such provisions or regulations have directly or indirectly replaced.

(f)     References to a "person" shall be construed so as to include any individual, firm, company, corporation or other body corporate, government, state or agency of a state or any joint venture, association, partnership, works council or employee representative body (whether or not having separate legal personality).

(g)   References to times of the day are to local time in the relevant jurisdiction unless otherwise stated.

(h)   References to any Panama legal term for any action, remedy, method, or judicial proceeding, legal document, legal status, court, official, or any legal concept or thing shall, in respect of any jurisdiction other than Panama, be deemed to include what most nearly approximates in that jurisdiction to the relevant Panama legal term.

(i)     The words "written" and "in writing" include any means of visible reproduction (including, without limitation, in electronic form or otherwise).

(j)     Any phrase introduced by the terms "including", "include", "in particular", or any similar expression shall be construed as illustrative and shall not limit the sense of the words preceding those terms.

(k)    An obligation on a party not to do something includes an obligation not to allow that thing to be done.

#### 2.              Access to and Use of the Software

A.              Subject to Developer's compliance with the terms and conditions of this Agreement, the Company grants Developer, a non-exclusive, limited, personal, non-transferable, non-assignable, revocable right and license to access and use the Software for the following purposes:

&#x20;                  i.      Use the Software to build, operate, and scale applications, agents, or bots (the “Developer Product”).

&#x20;                 ii.      Integrate the Software into internal or external services, subject to Rate Limits (defined below) and such applicable or fair use policy and limitations as may be imposed by the Company from time to time.

The Developer may only access and use the Software as provided herein and only in accordance with our applicable official documentation for such Software (available at <https://docs.game.virtuals.io/game-sdk>) (the “Documentation”), as may be updated from time to time in our sole discretion.

B.              The Developer acknowledges and agrees that the Software may include various components, features, and functionalities that the Company may provide from time to time, including but not limited to SDKs, APIs, access to third party decentralised applications, authentication infrastructure, digital wallet infrastructures, distributed signature generation systems, and related blockchain connectivity services, and that such Software are subject to the terms and conditions set forth herein. The scope and availability of Software may vary and are subject to modification at our discretion, as applicable.

C.             As between the Parties and subject to Clauses 2.A and 2.B above, the Company and its licensors own and retain all right, title and interest in and to: (a) the Software (including without limitation, any Third-Party Software components); (b) all logos and trademarks included in any of the foregoing that belong to the Company or any third-party licensor, and (c) any and all Intellectual Property Rights embodied in the foregoing. The Company reserves all rights not expressly granted in this Agreement, and no licenses are granted by the Company to the Developer, whether by implication, estoppel or otherwise, except as expressly set forth in this Agreement, and the Developer shall not challenge such ownership or validity of the same. Without prejudice to the generality of the foregoing, the Developer shall not, for any purpose, use or adopt any trademark, trade name or similar names that are owned by the Company and/or used by the Company or any of its third party licensor as a means of identifying itself without express written consent of the Company or any of its third party licensor.

D.             Feedback. The Developer may choose to submit comments, bug reports, ideas or other feedback about the Software, including, without limitation, about how to improve the Software (collectively, “Feedback”). All such title, rights and interests in such Feedback (including any Intellectual Property Rights subsisting therein) shall be held and owned solely by the Company. By submitting any Feedback, the Developer hereby agrees that the Company shall be free to use such Feedback at the Company’s discretion and without additional compensation to the Developer, and to disclose such Feedback to third parties (whether on a non-confidential basis, or otherwise). Any improvements made to the Software due to any Feedback shall belong exclusively to the Company and shall be considered the Company’s Intellectual Property Rights. The Developer hereby irrevocably and unconditionally transfers and assigns to the Company all Intellectual Property Rights it may have in any Feedback and any developments made as a result of such Feedback and waives any and all moral rights or other residual proprietary rights that the Developer may have in respect thereto. It is further understood that use of Feedback, if any, may be made by the Company at its sole discretion, and that the Company shall in no way be obliged to make use of any kind of the Feedback or part thereof.

E.              The Developer warrants it will not use the Software:

&#x20;                  i.      for any purpose not expressly authorized by this Agreement including redistribution, resale or other commercial purposes;

&#x20;                 ii.      for any illegal, illicit, harmful, defamatory, or abusive activity or purpose;

&#x20;                iii.      for any actions that infringe, misappropriate, or violate the rights of others;

&#x20;                iv.      in any manner that violates applicable laws and regulations; or

&#x20;                 v.      on behalf of any party, for any purpose, which is not a party to this Agreement.

F.              Except to the extent expressly permitted under this Agreement, the Developer warrants and undertakes that it will not:

&#x20;                  i.      directly or indirectly attempt to copy, duplicate, modify, translate, adapt, alter, create derivative works from, reverse engineer, disassemble, decompile or translate the Software or any component thereof, or attempt to create a substitute or similar service through use of or access to the Software;

&#x20;                 ii.      sell, lease, sublicense, distribute, redistribute, syndicate, assign, or otherwise transfer or provide access to the Software, in whole or in part, to any third party;

&#x20;                iii.      disrupt or interfere with the Software, including circumventing any Rate Limits, constraints, or bypassing any protective measures, access restrictions or safety precautions that have been implemented on the Software;

&#x20;                iv.      exploit any vulnerability of the Software, inject any unauthorized or malicious scripts, codes, commands, queries, or requests, or introduce any unauthorized code through the Software. In the event that the Developer is aware of any vulnerabilities in the Software or any part thereof, it shall immediately notify the Company, and shall ensure that it does not notify any third party without the prior written consent of the Company;

&#x20;                 v.      remove or alter any trademark, logo, copyright or other proprietary notices associated with the Software (or any part thereof);

&#x20;                vi.      use the Software to provide services for, or otherwise for the benefit of, third parties, including without limitation, using the Software to provide software as a service, platform as a services, or similar services offering;

&#x20;              vii.      exceed the applicable usage limitations, feature limitations, rate limits, or other applicable acceptable or fair usage expectations or other usage limits as may be stated in the Documentation or otherwise specified by the Company;

&#x20;          viii.         use any unauthorized process or software that intercepts, collects, crawls, scrapes, reads, or “mines” information or data generated or stored by the Software (or any part thereof, including any third party components) or the underlying Platform, or use the Software to develop any other software or tool that does the same;

&#x20;            ix.         engage in any conduct intended to disrupt or diminish the social experience for other users or developers, or disrupt the operation of the Company’s provision of the Software and the Platform in any way, including:

(a)   disrupting or assisting in the disruption of any server, equipment, hardware or computer system used to support the Software and/or the Platform  or interfering with, disrupting, negatively affecting or inhibiting other users or developers from enjoying access and use of the Software and the Platform, or in any action or conduct that could damage, disable, overburden, or impair the functioning of the Software and the  Platform. ANY ATTEMPT BY YOU TO DISRUPT THE SOFTWARE AND THE PLATFORM OR UNDERMINE THE LEGITIMATE OPERATION OF THE SOFTWARE AND THE PLATFORM MAY BE A VIOLATION OF CRIMINAL AND CIVIL LAWS.

(b)   harassment, “griefing,” abusive behaviour or conduct intended to unreasonably undermine or disrupt the Software usage or Platform experiences of others, and/or any other activity which violates this Agreement.

(c)   posting or transmitting unsolicited or unauthorized advertising, or promotional materials, that are in the nature of "junk mail," "spam," "chain letters," "pyramid schemes," or any other similar form of solicitation within the Platform.

&#x20;             x.         facilitate, create or maintain any unauthorized connection to the Software or the Platform  including without limitation (i) any connection to any unauthorized server that emulates, or attempts to emulate, the Software or the Platform; and (ii) any connection using third-party programs or tools not expressly authorized by the Company;

&#x20;            xi.         use the Software in any manner or for any purpose that involves deception, falsehoods, misrepresentations, or misleading statements, including impersonating someone;

&#x20;           xii.         disguise your location through IP proxying, VPN or other methods;

&#x20;             xiii.      circumvent or attempt to circumvent any aspect of the Software, which is designed to manage or restrict unauthorized access or use of the Software; or

&#x20;             xiv.      cause or permit any other party to do any of the foregoing, or use the Software to develop and/or operate any software or tool that does any of the foregoing.

G.             The Company shall have the right to monitor and/or record your access and usage of the Software when you use Software. The Company shall have the right to rely on any such records and information for any reason, including: (a) to satisfy any applicable law, regulation, legal process or governmental request; (b) to enforce the terms of this Agreement or any other of the Company’s policies; (c) to protect the Company’s legal rights and remedies; (d) to protect the health or safety of anyone that the Company believes may be threatened; or (e) to report a crime or other offensive behavior.&#x20;

#### 3.              Rate Limits and Access Tiers

A.              The Company provides access to, and use of, the Software on the following access tiers (each an “Access Tier”):

&#x20;                  i.      Basic Access: This is the default tier that is provided without charge, but with limits on features (“Feature Limits”) and on utilisation rates and call rates (“Rate Limits”); and

&#x20;                 ii.      Premium Access: The Premium Access tier is provided on a paid subscription basis, with access to more features, and higher Rate Limits. Premium Access is automatically unlocked by adding credits via the Platform.

B.              More details on the Access Tiers and the applicable Feature Limits, Rate Limits and pricing are available at  <https://docs.game.virtuals.io/game-sdk-usage-and-pricing>. We reserve the right to add, vary, modify or amend the Access Tiers (including without limitation, Rate Limits, pricing and Feature Limits) or throttle, limit, suspend or revoke access to the Software at any time and at our sole discretion for any reason whatsoever (including for the purpose of maintaining service integrity and ensuring your compliance with the terms of this Agreement).

C.             Upon the Developer adding sufficient credits to the Platform, the Premium Access to the Software will be provisioned automatically without any further action or approval by the Company. The Software will be deemed delivered when Premium Access is first enabled on the Developer’s account. The Developer acknowledges that the Company does not control the transfer of data over the internet and that the Company is not responsible for any delays or delivery failures caused by the internet. &#x20;

&#x20;                  i.      Any Access Credentials provided by the Company to the Developer are personal and specific to the Developer. The Developer may not distribute any Access Credentials provided by the Company to any third party. Such Access Credentials are the Confidential Information of the Company and are subject to the confidentiality requirements set out herein.

&#x20;              ii.         You are solely responsible for all activities conducted through your Access Credentials whether or not you authorize the activity. In the event that fraud, illegality or other conduct that violates this Agreement is discovered or reported (whether by you or someone else) that is connected with your Access Credentials, the Company may suspend or block your access to and use of the Software, whether for a period of time or indefinitely.

&#x20;             iii.         You are solely responsible for maintaining the confidentiality and security of your Access Credentials. You are solely responsible for any harm resulting from your disclosure, or authorization of the disclosure, of your Access Credentials (for example, passwords) or from any person's use of your access credentials to gain access to your Access Credentials. You acknowledge that in the event of any unauthorized use of or access to your User Account, access credential or other breach of security, you accept that due to the nature of the Platform, the Company will be unable to remedy any issues that arise, and the Company will not be responsible or liable for the same.

&#x20;            iv.         The Company will not be liable for any loss or damage (of any kind and under any legal theory) to you or any third party arising from your inability or failure for any reason to comply with any of the foregoing obligations, or for any reason whatsoever, except fraud on our part.

&#x20;             v.         The Company will not be liable for any loss or damage arising from unauthorized access to your Access Credentials.

#### 4.              Developer Responsibilities, Representations and Warranties

A.              General

&#x20;                  i.      The Developer is responsible for all activities that occur in connection with the Developer's access and use of the Software, including but not limited to the proper access and usage of the Software, and maintaining compliance with applicable laws and regulations.

&#x20;              ii.         The Developer agrees to provide all necessary notices and end user terms (collectively, “End User Terms”) to all end users (“End Users”) and obtain all required consents and agreements to such End User Terms in respect of the Developer’s End Users’ access and use of the Developer Product. Such End User Terms shall include, but not be limited to, disclosures of risks relating to the access and use of the Developer Product, and restrictions and terms and conditions no less stringent than those set out herein, security considerations, and any limitations on transaction reversal or credential recovery capabilities, End Users’ obligations to ensure that the Developer Product are used in a manner which complies with applicable laws and regulations, and other such terms and conditions as may be reasonably expected from similar terms and conditions used within the industry.

&#x20;             iii.         The Developer is solely responsible for ensuring that all Intellectual Property Rights used by the Developer in the development of the Developer Product and the access and use of the Software are properly owned or licensed by the Developer (the “Developer’s IPR”). The Developer shall be solely responsible for all matters relating to the Developer’s IPR  (including without limitation, any dispute, issue or claim of infringement raised by an End User or a third party in respect of the Developer Product and/or the Developer’s IPR). The Developer shall indemnify and hold the Platform and the Company, and each of its users, affiliates, officers, directors, employees, agents, and representatives (collectively, “Company Related Parties”) harmless from and against any and all claims, damages, liabilities, losses, costs, and expenses (including attorneys' fees) arising out of or in connection with any dispute, issue or claim of infringement brought by any End User or any third party relating to the Intellectual Property Rights used by the Developer for the purposes of this Agreement.&#x20;

&#x20;            iv.         The Developer acknowledges and agrees that the Software only provides back-end infrastructure for the Developer to develop and operate the Developer Product, and that the Developer Product is provided solely by the Developer, and the Developer is solely and wholly responsible and liable for the provision and operation of the Developer Product and all the features, functionality and services relating thereto, to the End Users. Accordingly, the Developer shall be fully responsible for resolving all issues, feedback, complaints, disputes or other matters relating to the End Users’ access and use of the Developer Product (each a “User Dispute”). The Developer acknowledges and agrees that each User that access and uses the Developer Product is entering into a direct contractual relationship with the Developer and not with the Company, and accordingly, the Company shall not be responsible or liable for any User Dispute(s) between an End User and the Developer. The Company may (but is not obligated to) assist in the resolution of any User Dispute(s) between an End User and the Developer but such assistance shall not be deemed as an assumption or recognition of responsibility by the Company.

B.              Security and Technological Matters

&#x20;                  i.      The Developer shall use best commercial efforts in accordance with applicable laws and good industry practice to:

(1)   ensure that no Harmful Code is contained in the Developer Product; and

(2)   not introduce any Harmful Code into the Platform, the Software or any Third-Party Software.

&#x20;                 ii.      If any Harmful Code is found (a) in the Developer Product; or (b) to have been introduced by the Developer into the Platform, the Software or any Third-Party Software:

(1)   the Developer shall report that fact to the Company as soon as practicable after the Developer becomes aware of it and provide all information reasonably requested by the Company in relation to the Harmful Code, its manner of introduction and the effect the Harmful Code has had or is likely to have;

(2)   the Developer shall co-operate fully with the Company and all such service providers or third parties designated by the Company in taking the necessary remedial action to eliminate the Harmful Code and shall itself take all reasonable steps to prevent reoccurrence (including implementing appropriate policies and processes to prevent further occurrences); and

(3)   if so directed by the Company, the Developer shall, at its own cost, remove the Harmful Code from its Developer Product and the Platform, the Software or any of the Third-Party Software and remedy any consequences of the introduction, execution or proliferation of the Harmful Code.

For the purposes of this Agreement, “Harmful Code” shall mean any computer instructions, circuitry, or other means whose purpose or intended effect is to (i) disrupt, disable, harm, or otherwise impede in any manner the operation of any component of the Developer Product, the Platform, the Software or any of the Third-Party Software(each a “System”) (sometimes referred to as “viruses” or “worms), (ii) disable or impair in any way the operation of any component of the System, or (iii) permit unauthorized access to any component of a System (sometimes referred to as “traps”, “back doors”, “access codes” or “trap door” devices), and any other harmful, malicious, hidden, or self-replicating procedures, routines or mechanisms whose purpose or intended effect is to cause any component of a System to cease functioning or to damage or corrupt data, storage media, programs, equipment or communications, or otherwise interfere with any part of the Company’s or the Developer’s or any third party’s operations.

&#x20;                iii.      The Developer is responsible for securing the Developer's own systems, applications, and infrastructure required to access and use the Software, including but not limited to implementing appropriate access controls, data protection measures, and incident response and resolution process and procedures. The Developer hereby acknowledges and agrees that vulnerabilities or security issues in the Developer Product and own systems could potentially affect the security of the Platform, the Software or any Third-Party Software, and the Developer hereby indemnifies the Company and/or the Company Related Parties from and against any and all claims, damages, liabilities, losses, costs, and expenses (including attorneys' fees) suffered by the Company and/or the Company Related Parties arising out of or in connection with such vulnerabilities.

&#x20;                iv.      As a developer of the Developer Product, you hereby acknowledge and agree that you owe certain duties and responsibilities to the Company, the Software, the Platform and your End Users in respect of the features and functionalities that you make available on the Developer Product, including without limitation:

(1)   ensuring that all features and functionalities made available on or via the Developer Product are in compliance with all applicable laws and regulations;

(2)   where any feature and/or functionality allow for transactions or interactions to be conducted with products and/or services provided by third parties (for example, on external third party platforms or Dapps) (each a “Third Party Interaction”), ensuring that such Third Party Interactions are not prohibited by the relevant third party product and/or service, and that such Third Party Interactions are in compliance with all applicable laws and regulations, and terms and conditions imposed by such third party products and/or services;

(3)   ensuring that all actions and transactions by End Users (each an “End User Transaction”) and Third Party Interactions conducted via the Developer Product are conducted accurately, correctly, in a timely manner and in accordance with the relevant End User’s instructions, inputs, specifications, parameters, and any other content or information that such User provides when using or interacting with the Developer Product (“End User Instruction”); and

(4)   implementing technological safeguards and restrictions into the Developer Product to ensure that all End User Instruction from End Users do not result in any User Transaction or Third Party Interaction that:

a.     violates applicable laws and regulations or this Agreement or the Terms;

b.     causes, enables or encourages the misuse, manipulation, exploitation, circumvention, sabotage, or abuse of the Platform, the Developer Product or the Software (including any Third-Party Software); or

c.     infringes, misappropriates or otherwise violates any Intellectual Property Rights privacy rights, publicity rights, or other legal rights of any third party or other End User or Developer.

C.             Developer’s Representations and Warranties

The Developer hereby represents and warrants that:

&#x20;                  i.      it has all permits, licenses, and other authorizations to develop, launch and operate the Developer Product;

&#x20;                 ii.      all documentation, details, information, parameters, specifications and data provided by the Developer are true, complete and accurate in all material respects with respect to the Developer and its Developer Product;

&#x20;                iii.      the Developer Product or any component or part thereof does not and will not infringe, dilute or otherwise violate, trespass or in any manner contravene, breach or constitute the unauthorized use or misappropriation of, or conflict with any Intellectual Property Rights, or any other property rights or proprietary rights, of any third party, and there is no claim or action pending or threatened against the Developer or the Developer Product alleging any of the foregoing. The use of the Software (including any Third-Party Software) will not constitute or result in any claim of impersonation, fraud or an infringement of any Intellectual Property Rights, or any other property rights or proprietary rights, of any third party, against the Software, the Platform or the Company;

&#x20;                iv.      there is no legal proceeding pending or, to the knowledge of the Developer, threatened with respect to, against or affecting or seeking to prevent or delay the development, launch, maintenance or operation of the Developer Product and no notice of any such legal proceeding involving or relating to the Developer, whether pending or threatened, has been received by the Developer or any agent thereof;

&#x20;                 v.      no personnel or member of the Developer or, to the Developer’s knowledge, employee or service provider assisting in the development and operation of the Developer Product, is: (i) the target of economic, financial sanctions, trade embargoes or export controls administered, enacted or enforced from time to time by the United States of America (“U.S.”), the United Nations Security Council, the European Union (“EU”), any EU member state, or the United Kingdom (regardless of its status vis-a-vis the EU) (collectively, the “Sanctions”); (ii) organized, operating from, incorporated or resident in a country or territory which is the subject of comprehensive export, import, financial or investment embargoes under any Sanctions (including without limitation, Cuba, Iran, North Korea, the Crimea region of Ukraine and Syria) (the “Sanctioned Country”); or (iii) unless otherwise disclosed in writing to the Company prior to Developer’s access and use of the Software, is a senior political figure or any immediate family member or close associate of a senior political figure. For purposes of this Agreement, a “senior political figure” is a senior official in the executive, legislative, administrative, military or judicial branches of a government (whether elected or not), a senior official of a major political party, or a senior executive of a government-owned corporation, including any corporation, business or other entity that has been formed by, or for the benefit of, a senior political figure; an “immediate family member” of a senior political figure are such person’s parents, siblings, spouse, civil partner, children and step-children; and a “close associate” of a senior political figure is a person who is widely and publicly known to maintain an unusually close relationship with the senior political figure, and includes a person who is in a position to conduct substantial financial transactions on behalf of the senior political figure.

&#x20;                vi.      the Developer shall honestly, completely and accurately represent the details, characteristics, strategy, outlook and business plan of the Developer Product in order to allow the End Users to undertake such due diligence as they may wish to undertake, and to make an informed and conscious decision concerning their access and use of the Developer Product;

&#x20;              vii.      the Developer shall communicate honest, accurate, timely and updated information relating to the Developer Product, and its use of the Software, to the Company and the End Users at all times; and

&#x20;             viii.      the Developer shall be solely responsible: (i) for any and all tax liabilities associated with payments between each of itself and any End User; (ii) for determining whether the Developer is required by applicable laws to issue any particular invoice to its End Users and for issuing any invoices so required; and (iii) for determining whether the Developer and/or an End User is required by applicable law to remit to the appropriate authorities any value added tax, sales tax or any other taxes and duties or similar charges, and remitting any such taxes or charges to the appropriate tax authorities, as applicable.&#x20;

D.             The Developer hereby acknowledges and agrees that:

&#x20;                  i.      the Company will be relying, and is so entitled to rely, upon the information, representations, warranties, and covenants made or provided by the Developer to the Company in the course of the Developer’s access and use of the Software; and

&#x20;                 ii.      the Company may cooperate with governmental authorities or regulatory authorities upon request, or contact governmental authorities or regulatory authorities at its discretion, if it suspects the Developer access and uses the Software, or develops, launches and operates the Developer Product for any criminal purpose, including money laundering, or in violation of applicable laws.

#### 5.              Fees, Payments, Taxes.

A.              Applicable Fees. Where applicable, the Company may charge you the following fees for the access and use of the Software:

&#x20;                  i.      fees for the utilisation of the relevant Software (based on the applicable Access Tier) (the “Usage Fee”) as specified in the Documentation. The Company reserves the right to change or revise the Usage Fee by updating the Documentation at any time without notice to the Developer, and any changes or revisions to the Usage Fee will be published on the Documentation. It is the Developer’s responsibility to take note of any changes or revisions to the Usage Fee, and the Developer shall be charged the updated Usage Fee for any further access and use of the relevant Software by the Developer after the Usage Fee is revised; and

&#x20;                 ii.      gas fees or transaction fees charged on the transactions conducted via the Software or through the Platform (“Gas Fees”). Where applicable, Gas Fees are paid to the third parties and/or network of computers that operate the relevant blockchain and/or process the transactions and are not paid to the Company. Kindly note that such Gas Fees often fluctuate based on a number of factors, all of which are not under the Company’s control, and may therefore vary or change at any time without notice.

B.              The Company may charge the applicable fees set out above by (i) automatically charging, deducting or debiting the applicable fees from any (a) prefunded deposit account or credit card provided by the Developer; or (b) any digital asset wallet connected or linked to the relevant Software or Platform by the Developer; or (ii) by the issuance of an invoice to the Developer, whereby the Developer shall make payment to the Company via the payment methods set out in Clause 5.C below. Where an invoice is issued, the relevant fees are due to the Company within thirty (30) days of the date of the Company’s invoice. In addition to any of its other rights or remedies (including, without limitation, any termination rights) under this Agreement, the Company reserves the right to suspend provision of the Software to the Developer: (a) if the Developer is overdue on any payment obligation, (b) if the Company deems such suspension necessary due to the Developer’s breach of applicable use restrictions in connection with the Software, or (c) as required by law or at the request of governmental entities.  If suspension is due to past due amounts under subsection (a) above, the applicable access to the Software will be resumed and/or restored upon receipt by the Company of all overdue amounts.  No suspension under this paragraph will relieve the Developer from complying with any of its obligations under this Agreement. &#x20;

C.             Payment Method and Currency. Except as may otherwise be agreed to between the Parties, all payments due under the Agreement will be made: (i) by fiat (through the means of a prefunded deposit account from which the Company may debit the relevant Usage Fees or Gas Fees from) or via bank wire transfer, electronic ACH deposit or company check in immediately available funds to an account designated by the Company); (ii) in USDT/USDC stablecoin (whereby the funds may be automatically deducted from a digital asset wallet that the Developer connects or links to the Platform or via transfer by the Developer to a digital asset wallet address specified by the Company); or (iii) in such other digital asset (such as cryptocurrencies) specified in writing to be acceptable by the Company (whereby the applicable digital assets may be automatically deducted from a digital asset wallet that the Developer connects or links to the Platform or via transfer by the Developer to a digital asset wallet address specified by the Company).

D.             Taxes. The fees payable by the Developer under this Agreement do not include taxes. The Developer will pay any and all sales, use, excise, import, export, value added, goods and services tax or similar taxes (“Transaction Taxes”) and all government permit or license fees, and all customs, duty, tariff and similar fees levied upon the sale of the subscriptions and licenses to the Software under the Agreement, exclusive of income taxes based on the Company’s net income. The Company will pay any costs associated with the collection of Transaction Taxes, including penalties and interest. If the Developer is required to pay any withholding tax, charge or levy with respect to payments to the Company (“Withholding Taxes”), the Developer agrees to gross up payments actually made to the Company such that the Company receives sums due in full and free of any deduction of any such Withholding Tax.

#### 6.              Confidentiality; Data Protection; Publicity.

A.              Confidentiality.

&#x20;                  i.      “Confidential Information” means all information disclosed (whether in oral, written or other tangible or intangible form) by one party (the “Disclosing Party”) to the other party (the “Receiving Party”) concerning or related to the business relationship (or potential business relationship) between the parties, whether before, on or after the date of the Developer’s first access and use of the Software (the “Effective Date”) that is: (i) characterized as confidential information at the time of disclosure or within a reasonable time after disclosure; or (ii) that due to the nature of the information and circumstances surrounding its disclosure would be reasonably understood by a person with no knowledge of the relevant trade or industry to be confidential or proprietary. Such Confidential Information includes, without limitation, (1) concepts and ideas relating to the development and distribution of content in any medium or to the current, future and proposed products or services of the Disclosing Party or its subsidiaries or affiliates; (2) trade secrets, drawings, inventions, know-how, software programs, and software source documents; (3) information regarding plans for research, development, new service offerings or products, marketing and selling, business plans, business forecasts, budgets and unpublished financial statements, licenses and distribution arrangements, prices and costs, suppliers and customers; (4) existence of any business discussions, negotiations or agreements between the parties; (5) any information regarding the skills and compensation of employees, contractors or other agents of the Disclosing Party or its subsidiaries or affiliates, and (6) the details and information set out in this Agreement and the Documentation (to the extent such information is confidential).  Confidential Information also includes proprietary or confidential information of any third party licensor who may disclose such information to the Company or the Developer in the course of the Developer’s access and use of the Software. Confidential Information will not include information that: (i) is in or enters the public domain without breach of the Agreement and through no fault of the Receiving Party; (ii) the Receiving Party can reasonably demonstrate was in its possession prior to first receiving it from the Disclosing Party; (iii) the Receiving Party can demonstrate was developed by the Receiving Party independently and without use of or reference to the Disclosing Party’s Confidential Information; or (iv) the Receiving Party receives from a third party without restriction on disclosure and without breach of a nondisclosure obligation.&#x20;

&#x20;                 ii.      Period of Confidentiality. The Receiving Party will, during the term of this Agreement and for five (5) years thereafter, be required to maintain the confidentiality of the Disclosing Party’s Confidential Information by using the same degree of care to maintain the confidentiality of such Confidential Information that it uses to maintain the confidentiality of its own Confidential Information, but in no event less than reasonable care. Notwithstanding the foregoing, where the Confidential Information disclosed is: (i) the Disclosing Party’s trade secret, the Receiving Party will treat such information as Confidential Information for as long as the Confidential Information remains the Disclosing Party’s trade secret; or (ii) required by law to be protected for a duration beyond that provided hereunder, the Receiving Party will maintain such information in confidence for the duration required by law.

&#x20;                iii.      Use; Disclosure. Any Confidential Information of the Disclosing Party will be used by the Receiving Party solely for the purpose of carrying out the Receiving Party’s obligations under this Agreement. In addition, the Receiving Party will not reproduce Confidential Information disclosed by the Disclosing Party, in any form, except as required to accomplish the Receiving Party’s obligations under this Agreement. The Receiving Party may disclose Confidential Information to the extent compelled to do so pursuant to a judicial or legislative order or proceeding; provided that, to the extent permitted by applicable law, the Receiving Party provides to the Disclosing Party prior notice of the intended disclosure and an opportunity to respond or object to the disclosure, or if prior notice is not permitted by applicable law, prompt notice of such disclosure; and provided further that the Receiving Party must limit the scope of Confidential Information that is disclosed to only that which is required to be disclosed by the applicable order or proceeding.

&#x20;                iv.      Remedy for Breach. The parties agree that damages may be an inadequate remedy in the event of a breach of this Clause 6.A. Therefore, the Parties agree that a party is entitled, in addition to any other rights and remedies otherwise available, to seek injunctive and other equitable relief in the event of a breach or threatened breach by the other party of this Clause 6.A.

B.              Data Protection. The Company’s Privacy Policy (accessible at \[<https://app.virtuals.io/privacy\\_policy.pdf>]), as may be updated by the Company from time to time, will apply to and govern (a) the Company’s handling, storing, and otherwise treating of the various types of data identified therein in connection with the Developer’s use of the Software, and (b) the Developer’s rights and obligations with respect to such data in connection with the Developer’s use of the Software. The Company’s Privacy Policy (including capitalized terms therein) is hereby incorporated into this Agreement by reference.

C.             Publicity. The Company shall have the right to include the Developer’s name and logo on the Company’s website and other public customer lists. The Developer agrees to cooperate with the Company, at Company’s reasonable request, on public content that describes the Developer’s election to use the Software, including, but not limited to, announcements, press releases, social media posts, and other public communications or publications describing the Developer’s election to use the Software, and publication of results, data, information, or other written or video success stories describing the use of the Software.

#### 7.              Warranties; Disclaimer.

A.              General Warranties. Each Party warrants that as of the Effective Date: (i) it validly exists and is in good standing under the laws of the place of its establishment or incorporation; (ii) it has full corporate power and authority to execute, deliver and perform its obligations under this Agreement; (iii) the person signing this Agreement on its behalf has been duly authorized and empowered to do so; and (iv) this Agreement is valid, binding and enforceable against it in accordance with its terms.

B.              General Disclaimers. TO THE FULLEST EXTENT ALLOWED BY APPLICABLE LAW, THE SOFTWARE (AND ALL THIRD-PARTY SOFTWARE) ARE PROVIDED ON AN “AS IS”, “UNDER DEVELOPMENT”, "WITH ALL FAULTS" AND “AS AVAILABLE,” BASIS FOR USE, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED. THE COMPANY AND ITS THIRD PARTY LICENSORS AND SUPPLIERS DISCLAIM ANY AND ALL OTHER WARRANTIES (EXPRESS OR IMPLIED, ORAL OR WRITTEN) WITH RESPECT TO THE SOFTWARE (AND THIRD PARTY SOFTWARE), WHETHER ALLEGED TO ARISE BY OPERATION OF LAW, BY REASON OF CUSTOM OR USAGE IN THE TRADE, BY COURSE OF DEALING OR OTHERWISE, INCLUDING ANY AND ALL: (I) WARRANTIES OF MERCHANTABILITY; (II) WARRANTIES OF FITNESS OR SUITABILITY FOR ANY PURPOSE (WHETHER OR NOT THE COMPANY KNOWS, HAS REASON TO KNOW, HAS BEEN ADVISED, OR IS OTHERWISE AWARE OF ANY SUCH PURPOSE); AND (III) WARRANTIES OF NONINFRINGEMENT OR CONDITION OF TITLE. THE COMPANY AND ITS THIRD PARTY LICENSORS AND SUPPLIERS MAKE NO WARRANTIES WITH RESPECT TO THE SOFTWARE (INCLUDING THE THIRD-PARTY SOFTWARE).

C.             Blockchain Related Disclaimers:

&#x20;                  i.      The Company and the Software could be impacted by one or more regulatory inquiries or regulatory action, which could impede or limit the Developer’s ability to access or use the Software or the Platform, or other decentralised protocols or networks or other applicable blockchain. The Company has no control over, and cannot be responsible or liable for, any errors, delays, failures, defects, or other issues caused by such decentralized protocols, networks, or other applicable blockchains. The Company, the Software and the Platform are not registered or licensed by any governmental or regulatory authority or agency. No governmental or regulatory authority or agency has reviewed or approved the Company, the Software or the Platform provided thereunder.

&#x20;                 ii.      There are risks associated with using an internet-based currency, including, but not limited to, the risk of hardware, software, and internet connection failure or problems, and the risk of malicious software introduction. The Developer accepts and acknowledges that the Company will not be responsible for any communication failures, disruptions, errors, distortions or delays that may be experienced when accessing and using the Software, however caused.

&#x20;                iii.      The Developer acknowledges and agrees that the Software are software code and are subject to flaws, and acknowledges that the Developer is solely responsible for evaluating any smart contract or source code provided by the Company. Like all software, the Software (and Third-Party Software) may be subject to exploits. The Company is not and will not be responsible for exploits of any kind. While the Company has taken a number of precautions to maintain the security of the Software, respectively, this is a nascent technology, and it is not possible to guarantee that the software code or any smart contracts are completely free from vulnerabilities, bugs, or errors. The Developer accept all risks that arise from using the Software. The Developer further expressly acknowledges and agrees that any relevant protocol, network applications, or other blockchain applications can be written maliciously or negligently, and that the Company cannot be held liable for the interaction between the Developer and such relevant protocols, network applications, or other blockchain applications. This warning and others later provided by the Company in no way evidence or represent an ongoing duty to alert the Developer to all of the potential risks of utilizing the Software.

&#x20;                iv.      The following risks are associated with blockchain based technologies in general: the risk of losing private keys, theft resulting from third parties discovering private keys, value fluctuation of digital assets on the secondary market, disruptions to any applicable protocol or network caused by network congestion, lack of usability of, or loss of value with respect to, digital assets due to a hard fork or other disruption to any applicable protocol or network, or errors, bugs, or vulnerabilities in the smart contract code associated with a given digital asset or transactions involving digital assets.

&#x20;                 v.      Upgrades, forks, or changes to the blockchain or a change in how transactions are confirmed on the blockchain may have unintended, adverse effects. In the event of a change to an underlying blockchain network or other network disruption, resulting in a fork of the existing blockchain into one (or more) additional blockchains, the Software may or may not halt and may stop functioning. In addition, in the event of a fork, transactions on the network may be disrupted, including transactions involving Software.&#x20;

#### 8.              Indemnification Obligations.

&#x20;A.              The Developer agrees to indemnify, defend, and hold harmless the Company, its affiliates, officers, directors, employees, agents, and representatives from and against any and all claims, damages, liabilities, losses, costs, and expenses (including attorneys' fees) arising out of or relating to (i) any breach by the Developer of this Agreement; (ii) the development, launch and operation of the Developer Product; (iii) any disputes or issued raised between the Developer and an End User relating to or in connection with any User Transaction or Third Party Interaction; and/or (iv) any claim of infringement of Intellectual Property Rights or other proprietary rights by a third party (including any End User) resulting from the development, provision and  operation of the Developer Product, or the use of the Developer’s IPR by the Company under these terms.

#### 9.              Limitation of Liability.

A.              (I) IN NO EVENT WILL THE COMPANY BE LIABLE TO THE DEVELOPER OR ANY THIRD PARTY FOR ANY LOSS OF PROFITS, LOSS OF USE, LOSS OF REVENUE, LOSS OF GOODWILL, LOSS OF DATA, ANY INTERRUPTION OF BUSINESS, OR FOR ANY OTHER INDIRECT, SPECIAL, INCIDENTAL, EXEMPLARY, PUNITIVE OR CONSEQUENTIAL DAMAGES OF ANY KIND ARISING OUT OF OR IN CONNECTION WITH THESE DEVELOPER TERMS AND THE ACCESS AND USE OF THE SOFTWARE AND THE PLATFORM, WHETHER IN CONTRACT, TORT, STRICT LIABILITY OR OTHERWISE, EVEN IF SUCH PARTY HAS BEEN ADVISED OR IS OTHERWISE AWARE OF THE POSSIBILITY OF SUCH DAMAGES. (II) THE COMPANY’S TOTAL LIABILITY ARISING OUT OF OR RELATED TO THIS AGREEMENT WILL NOT EXCEED THE LOWER OF (X) US$1,000 AND (Y) THE TOTAL AMOUNT OF THE USAGE FEE PAID BY THE DEVELOPER IN THE SIX (6) MONTHS’ PRECEDING THE ACCRUAL OF THE CLAIM.

B.              CLAUSE 9 WILL BE GIVEN FULL EFFECT EVEN IF ANY REMEDY SPECIFIED IN THIS THE AGREEMENT IS DEEMED TO HAVE FAILED OF ITS ESSENTIAL PURPOSE.

#### 10.           Modification, Suspension and Termination

A.              This Agreement will become binding upon the Developer’s access and use of the Software and shall continue until terminated in accordance with the provisions hereof. Either party may terminate this Agreement and the Developer’s access and use of the Software at any time, with or without cause, upon reasonable notice to the other party, though the specific notice requirements may vary depending on the circumstances of termination and the particular services being utilized.

B.              Upon termination, the Developer's right to access and use the Software (including any Third-Party Software) shall immediately cease. The Developer acknowledges that termination of this Agreement may affect the functionality of the Developer Product, and that the Developer may need to implement alternative solutions or migration procedures to maintain service continuity for its End Users. The Company shall use commercially reasonable efforts to provide reasonable notice of termination when practicable, but the Developer acknowledges that immediate termination may be necessary in certain circumstances.&#x20;

#### 11.           Third-Party Software

A.              Notwithstanding any terms to the contrary in this Agreement, the Developer acknowledges and agrees that: (a) the Software contain Third-Party Software; and (b) the Developer agrees that, in addition to the terms of this Agreement, its use is further subject to the terms of licenses applicable to the Third-Party Software (including without limitation, the terms set out in this Clause 11). The Developer hereby acknowledges that the Company may make a list of Third-Party Software available to the Developer: (i) with the Documentation, (ii) in the notice file that accompanies the Software, and/or (iii) in another reasonable manner. Further, the Developer hereby acknowledges that third-party suppliers (such as the Third Party Licensors) may disclaim and make no representation or warranty with respect to such Third-Party Software or any portion thereof, and assume no liability for any claim that may arise with respect to such Third-Party Software or the Developer’s use or inability to use the same.

B.              NOTWITHSTANDING ANY OF THE TERMS IN THE THIRD-PARTY LICENSES, THIS AGREEMENT OR ANY OTHER AGREEMENT THE DEVELOPER MAY HAVE WITH THE COMPANY, THE COMPANY: (I) PROVIDES THIRD-PARTY SOFTWARE TO THE DEVELOPER AS-IS, WITHOUT WARRANTIES OF ANY KIND; (II) DISCLAIMS ANY AND ALL EXPRESS AND IMPLIED WARRANTIES WITH RESPECT TO THIRD-PARTY SOFTWARE, INCLUDING BUT NOT LIMITED TO IMPLIED WARRANTIES OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE; (III) IS NOT LIABLE TO THE DEVELOPER, AND WILL NOT DEFEND, INDEMNIFY, OR HOLD THE DEVELOPER HARMLESS FOR ANY CLAIMS ARISING FROM OR RELATED TO THIRD-PARTY SOFTWARE; AND (IV) WITH RESPECT TO THE THIRD-PARTY SOFTWARE, THE COMPANY IS NOT LIABLE TO DEVELOPER FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE OR CONSEQUENTIAL DAMAGES INCLUDING, BUT NOT LIMITED TO, DAMAGES RELATED TO LOST REVENUE, LOST PROFITS, LOSS OF INCOME, LOSS OF BUSINESS ADVANTAGE OR DAMAGE TO, OR UNAVAILABILITY, LOSS OR CORRUPTION OF DATA.

C.             Through your access and use of the Software, you may be able to access and interact with the X (formerly Twitter) platform (“X”), and its APIs. If you do interact with X or any of its APIs, you shall comply full with the [GAME X API Usage Terms](/game-x-api-terms-of-use) and the  [X API Rulebook,](https://help.x.com/en/rules-and-policies) which outlines acceptable behaviors, limitations, and automation guidelines in respect of any usage of X. This includes but is not limited to:

&#x20;                  i.      Restrictions on automated replies, DMs, follows, and posts

&#x20;                 ii.      Proper labeling of AI-generated content

&#x20;                iii.      Spam and engagement farming limitations

&#x20;                iv.      Tiered access rules (Tier 1 vs Tier 2) and rate limits

D.             By using the Software to access and interact X, you agree to follow the X API Rulebook. You are also responsible for ensuring compliance with the official [X Developer Agreement and Policy](https://developer.x.com/en/developer-terms/agreement). Failure to comply may result in immediate revocation of access to the Software. We reserve the right to modify or enforce new rules at any time.

E.              For avoidance of doubt, nothing in this Agreement should be deemed as or construed as the Company or the Platform offering to license, sell, distribute, lend, rent or provide the Developer with any of X’s APIs or other products and services as part of the Software. Any interaction that a Developer may have with X’s APIs or other products and services are merely incidental to the Developer’s access or use of the Software.

F.     The Software may also enable you to interact with other Third-Party Software (or third party services), such as interfacing with Ethereum, Discord, and other compatible environments. In all such cases, the Developer must:

&#x20;                  i.      Respect the integrity and intended use of all supported platforms.

&#x20;                 ii.      Avoid abusive automation or disruptive behavior.

&#x20;                iii.      Implement proper user consent and privacy safeguards.

#### 12.           Miscellaneous.

A.              Entire Agreement and Conflicts. This Agreement, and any exhibits, attachments, or addendums thereto set forth the entire agreement and understanding of the parties relating to the subject matter of this Agreement, and supersede all prior or contemporaneous agreements, proposals, negotiations, conversations, discussions and understandings, written or oral, with respect to such subject matter and all past dealing or industry custom. This Agreement will prevail over any additional, conflicting or inconsistent terms and conditions which may be submitted in any other ordering or purchasing document provided by the Developer, and any additional terms and conditions in any such document will have no force or effect, notwithstanding the Company’s acceptance or execution of the same.

B.              Independent Contractors. Neither party will, for any purpose, be deemed to be an agent, franchisor, franchise, employee, representative, owner or partner of the other party, and the relationship between the parties will only be that of independent contractors. Neither party will have any right or authority to assume or create any obligations or to make any representations or warranties on behalf of any other party, whether express or implied, or to bind the other party in any respect whatsoever.

C.             Assignment. Neither this Agreement, nor any right or duty under this Agreement, may be transferred, assigned or delegated by the Developer, by operation of law or otherwise, without the prior written consent of the Company, and any attempted transfer, assignment or delegation without such consent will be void and without effect. The Company may transfer, assign or delegate this Agreement or its rights and duties under this Agreement. Subject to the foregoing, this Agreement will be binding upon and will inure to the benefit of the Parties and their respective representatives, heirs, administrators, successors and permitted assigns.

D.             Amendments and Waivers. No modification, addition or deletion or waiver of any rights under this Agreement will be binding on a Party unless made in writing and signed by a duly authorized representative of each Party. No failure or delay (in whole or in part) on the part of a Party to exercise any right or remedy hereunder will operate as a waiver thereof or effect any other right or remedy. Except as otherwise expressly set forth herein, all rights and remedies hereunder are cumulative and are not exclusive of any other rights or remedies provided hereunder or by law. The waiver of one breach or default or any delay in exercising any rights will not constitute a waiver of any subsequent breach or default.

E.              Force Majeure. Except for payments, neither Party will be responsible for any failure to perform or delay attributable in whole or in part to any cause beyond its reasonable control, including but not limited to acts of God, government actions, pandemic, war, civil disturbance, terrorist acts, insurrection, sabotage, labor shortages or disputes, issues with subcontractors, transportation difficulties or shortage of energy, raw materials or equipment. In the event of any such delay, the date of delivery will be deferred for a period equal to the time lost by reason of the delay.

F.              Notices. Any notice, request, demand, consent or other communication required or permitted to be given by this Agreement to a Party is to be given in writing, in English, and may be (i) delivered by hand or by pre-paid first-class post or other next working day delivery service and addressed to the address set out on the first page of this Agreement or to a Party’s registered office (if different) or (ii) sent by email to the following addresses (or an address substituted in writing by the party to be served):

&#x20;                  i.      If to the Company: <hello@virtuals.io>

&#x20;                 ii.      If to You. All notices given by the Company under these Terms shall be given to you either through written notice, email, or website blog post.

G.             Section Headings. The section headings contained in this Agreement are for reference purposes only and will not affect in any way the meaning or interpretation of this Agreement.

H.             Attorneys’ Fees. In any action to enforce this Agreement, the prevailing party will be entitled to recover its costs and attorneys’ fees from the non-prevailing party.&#x20;

I.               Governing Law; Dispute Resolution. This Agreement shall be governed by and construed in accordance with the laws of Panama, without giving effect to the rules, principles, or laws regarding conflicts of law thereof. Any dispute arising under this Agreement (a “Dispute”) shall be resolved and shall be finally settled by arbitration in Panama at the Arbitration and Settlement Centre of Panama (“CECAP”) by a single arbitrator appointed under the arbitration rules of the CECAP in force at the time such arbitration is commenced. All disputes concerning or relating to arbitrability of Disputes under this Agreement or the jurisdiction of the arbitrators shall be resolved by the arbitrators. The venue and seat of arbitration shall be Panama, and all arbitration proceedings shall be confidential. The award rendered in any arbitration commenced hereunder shall be final and conclusive and binding upon the parties on the date it is rendered. The parties may enforce any award rendered by the arbitrator in any court of competent jurisdiction.

J.              Severability. If any provision of this Agreement is invalid, illegal, or incapable of being enforced by any rule of law or public policy, all other provisions of this Agreement will nonetheless remain in full force and effect. Upon such determination that any provision is invalid, illegal, or incapable of being enforced, the parties will negotiate in good faith to modify this Agreement so as to effect the original intent of the parties as closely as possible in an acceptable manner to the end that the transactions contemplated hereby are fulfilled.

K.              Counterparts. This Agreement may be executed: (i) in two or more counterparts, each of which will be deemed an original and all of which will together constitute the same instrument; and (ii) by the Parties by exchange of signatures by electronic means or scanned and emailed signature service where legally permitted. For clarity, electronic, digital, machine-generated or images of signatures will create a valid and binding obligation of the party so signing.

L.              Anti-Corruption Compliance. Each party will comply with all applicable anti-corruption laws, including the U.S. Foreign Corrupt Practices Act (“FCPA”), the U.K. Bribery Act, and all other applicable anti-corruption laws. Each party acknowledges and agrees that no payment or gift of money or anything of value has been or will be offered, authorized, promised, provided or paid, directly or indirectly, to any government official, state-owned enterprise official, public international organization official, political party official (or candidate for such office) or political party for the purpose of influencing official acts and decisions (including failures to act or decide) in order to assist the other party in obtaining or retaining an improper business advantage. Each party will promptly notify the other party if it receives a request to take any action which may violate its obligations under this Clause 12.L.

M.             Export Controls and Trade Sanctions Compliance. The Developer represents and warrants that: (i) the Developer is not a citizen or resident of, or located within, a country or territory that is subject to comprehensive U.S. trade sanctions or other significant trade restrictions (including without limitation Crimea, Cuba, Iran, North Korea, and Syria); (ii) neither the Developer nor its ultimate beneficial owners, if applicable, are identified on any U.S. government restricted party lists (including without limitation lists administered by the U.S. Treasury Department’s Office of Foreign Assets Control (“OFAC”) such as the Specially Designated Nationals and Blocked Persons List, Foreign Sanctions Evaders List, and Sectoral Sanctions Identifications List, or lists administered by the U.S. Commerce Department’s Bureau of Industry and Security (“BIS”) such as the Denied Party List, Entity List and Unverified List); and (iii) that no content created or submitted by the Developer is subject to any restriction on disclosure, transfer, download, export or re-export under the Export Control Laws. The Developer shall not use, nor allow the transfer, transmission, export or re-export of the Software or any portion thereof, technology, services or data, in violation of any Export Control Laws administered by the BIS, OFAC, or any other U.S. government agency, nor shall the Developer’s use of such products, technology, services or data give rise to a violation by the Company of any Export Control Laws or any other applicable export control and economic sanctions laws and regulations. The Developer acknowledges that the Software may not be available in all jurisdictions and that the Developer is solely responsible for complying with the applicable laws associated with its business and services. The Company may immediately suspend the provision of the Software and/or terminate this Agreement upon written notice to the Developer if the Company reasonably believes that the Developer is in violation of this Clause. “Export Control Laws” mean applicable export control and trade sanctions laws, rules, and regulations that prohibit or restrict the import, export, re-export, or transfer of products, technology, services or data, directly or indirectly, to or for certain countries, end uses or end users, including without limitation the regulations administered by BIS and OFAC.

N.             Audit for Compliance. During the term of this Agreement and for two (2) years thereafter, the Company may audit the Developer’s use of the Software directly or via an independent auditor on behalf of the Company. The Developer shall provide the Company and/or such independent auditor access to the Developer’s applicable systems, books and records, no more than once every calendar year (absent non-compliance in an immediately preceding audit), during the Developer’s normal business hours and in a manner that does not unreasonably interfere with the Developer’s normal business operations, to ensure the Developer’s compliance with the terms and conditions of this Agreement. Each party will pay the costs that it incurs in the course of the audit. If the audit reveals an underpayment, or a failure by the Developer to fully comply with all the terms and conditions of this Agreement, then the Developer will immediately pay the Company the underpaid amount, with interest accruing at the rate of 3% per month, or the highest rate permitted by law, whichever is lower, from the date such amount is due until the date such amount is finally paid in full. In addition, if any audit reveals an underpayment of more than five percent (5%) for any reporting period, the Developer will, without limiting the Company’s other rights and remedies at law or in equity, also reimburse the Company for its reasonable costs incurred in conducting such audit.

Last Updated: 16 October 2025

&#x20;&#x20;


# GAME X API Terms of Use

<h2 align="center">GAME X API Usage Terms</h2>

These **Supplemental Terms** govern your use of the **GAME X API integration** (the “**X Integration**”) and form part of the [**GAME Terms of Use**](/game-terms-of-use) (the “**Master Terms**”). Capitalized terms not defined here have the meanings in the Master Terms. If there is a conflict, the stricter term controls. The [**X Developer Agreement and Policy**](https://developer.x.com/en/developer-terms/agreement-and-policy) (collectively, “**X Terms**”) also apply; where the X Terms are stricter, the X Terms prevail. Violation of any rule may result in immediate suspension or revocation of your access. We reserve the right to modify API behaviour, rate limits, or access permissions at any time, with or without prior notice.

#### 1. Definitions

1.1 **“Application”** means your software product(s) that use the GAME SDK and the X Integration under your account.\
1.2 **“Agent”** means an automated process, bot, or agentic module that posts, replies, or sends DMs via X.\
1.3 **“X Content”** means content obtained from or submitted to X via the X Integration (including DMs).\
1.4 **“You”** means the account holder and any affiliates, developers, or contractors acting on your behalf.

#### 2. Acceptance and Modifications

By enabling or using the X Integration, you accept these Supplemental Terms. We may modify behavior, rate limits, or access permissions at any time (with or without notice). Your continued use constitutes acceptance of changes.

#### 3. Compliance; Responsibility

3.1 You are solely responsible for ensuring your use complies with (a) the Master Terms; (b) these Supplemental Terms; and (c) the X Terms.\
3.2 You will implement reasonable controls to prevent misuse, including human review where appropriate.

#### 4. Usage Limits and Conduct Rules

**The following are binding maximums unless we approve otherwise in writing:**

4.1 **Posting & General Behavior**\
(a) ≤ **50 posts per day** per X account.\
(b) Follow/unfollow actions: **< 100 per day** per X account.\
(c) Use organic, varied language; avoid repetitive or robotic phrasing.\
(d) Vary formats (images, video, text, polls, threads, quotes, retweets) and mark accounts as sensitive where appropriate.\
(e) Clearly disclose automation: include an **automated/agent-generated** label where required by policy or law.\
(f) Do **not** post in high-frequency bursts (e.g., every \~10–15 minutes or faster) or otherwise simulate engagement spikes.

4.2 **Replies, Mentions, and DMs**\
(a) **Replies:** ≤ **10 replies per hour** to **different users**.\
(b) **DMs to new users:** ≤ **10 per day**.\
(c) An Agent may only reply or DM upon a **valid inbound interaction** (e.g., the user mentions, replies, retweets, or DMs the Agent).\
(d) **One** automated reply or DM **per interaction**.\
(e) Validate the target post’s existence/availability (e.g., `statuses/lookup`) **before** replying.\
(f) Implement filters for sensitive usernames, media, or content in accordance with the X Terms.

4.3 **DM-Specific Restrictions**\
(a) DMs must be **triggered by a valid user interaction**; no unsolicited DM campaigns.\
(b) Permitted endpoints (illustrative, not exhaustive):\
&#x20;   • `GET /dm_conversations`\
&#x20;   • `GET /dm_events`\
&#x20;   • `POST /dm_events/new`\
(c) **No crawling, scraping, or off-platform storage** of DM data beyond what is necessary to operate your Application, and then only for the minimum time required.\
(d) Do **not** use DMs to **bypass rate limits** or coordinate bot activity.\
(e) **One DM per valid trigger**; no DM spam or sequences.

4.4 **Prohibited Activities**\
(a) Liking tweets or adding users to lists/collections via automation.\
(b) “Engagement farming” (e.g., repetitive “Like if…” prompts).\
(c) Auto-posting about trending topics solely to harvest reach.\
(d) Duplicate or substantially similar phrases across posts or accounts.\
(e) Over-replying or over-DMing beyond the limits above.\
(f) Misleading, redirect-heavy, or deceptive links.\
(g) Harassment, abuse, hate speech, doxxing, or other unlawful or harmful conduct.\
(h) Operating, cloning, or coordinating **multiple automated accounts** for substantially similar purposes to amplify content or skirt limits.

#### 5. No Resale or Repackaging

5.1 You may **not** redistribute, resell, sublicense, rent, lease, white-label, or otherwise commercially exploit the X Integration, any plugins, or access to the X API on a standalone basis or via your own wrappers, gateways, multi-tenant endpoints, or “credit” systems.\
5.2 You may not expose plugin or X API functionality as a general-purpose service to third parties outside your Application’s end-users under your account.

#### 6. Credentials, Security, and Rate Limits

6.1 API keys and tokens are **project-bound**, non-transferable, and must not be shared, published, or embedded in public repositories or distributed binaries.\
6.2 You must not attempt to obscure usage, rotate identities to evade controls, or otherwise bypass rate limits.\
6.3 You will implement industry-standard security to protect credentials and X Content.

#### 7. Data Handling and Privacy (DMs and User Data)

7.1 Collect, process, retain, and delete X Content **solely as necessary** to provide your Application’s functionality to the end-user initiating the interaction.\
7.2 Do not build user profiles from DMs or repurpose DM data for unrelated analytics or advertising.\
7.3 Comply with all applicable privacy, data protection, and record-keeping laws.

#### 8. Monitoring; Audit; Enforcement

8.1 We may monitor usage and logs (in a privacy-respecting manner) and may request reasonable information to verify compliance.\
8.2 We may **suspend or revoke** access immediately for suspected or actual breach, risk to users or platforms, or violation of the X Terms.\
8.3 You must promptly remediate any non-compliance and cooperate with investigations.

#### 9. API Access Tiers

**Tier 1 – Default.** Basic access; standard limits.\
**Tier 2 – Elevated.** Higher limits, subject to approval. Request by topping up credits at [**console.game.virtuals.io**](https://console.game.virtuals.io). We may adjust tiers or limits at any time.

#### 10. Warranties

10.1 You represent and warrant that your use will comply with these Supplemental Terms and the X Terms.\
10.2 You will **indemnify, defend, and hold harmless** Company and its affiliates from any third-party claims arising from your use of the X Integration, including violations of the X Terms or applicable law.\
10.3 The X Integration is provided **“as is”** and subject to the disclaimers and limitations in the Master Terms.

#### 11. Suspension, Termination and Survival

We may suspend or terminate the X Integration (in whole or part) at any time. Sections **5–8, 10–12** survive termination.