The digital landscape is undergoing a significant transformation, with the emergence of new platforms that empower a new class of virtual developers and founders. These pioneers are building and monetizing AI-driven autonomous agents in a decentralized, co-owned ecosystem.
Opportunities on Virtuals Protocol
The core thesis of platforms like Virtuals Protocol is the convergence of AI, gaming, blockchain, and co-ownership models.
This creates a unique environment for innovation and wealth creation and I am tired of seeing only scanners taking advantage of them.
Here are some opportunities:
Developers can create their own AI agents using the platform's "Generative Autonomous Multimodal Entities" (GAME) framework. These agents can act as digital workers, generating revenue through their activities within games, social media, and other applications. The protocol handles the creation, deployment, and revenue distribution, as described in this article allowing creators to focus on the intelligence and functionality of their agents.
The Agent Commerce Protocol (ACP), part of the Virtuals ecosystem, provides a trustless and verifiable layer for AI-driven commerce. Developers can create agents that negotiate, transact, and validate agreements ONCHAIN with other AI systems without human intervention, opening up a new frontier for automated business processes.
For more technical builders, there's an opportunity to contribute to the underlying infrastructure that powers this ecosystem. This includes developing tools for managing on-chain and off-chain states, enhancing memory systems with knowledge graphs, and creating new deployment runners for specialized agents.
An hackathon will be running next month to build that info using the game SDK for autonomous onchain agents.
How the sdk works
It's a straightforward way for the agent to interact with a state and make decisions based on it, functions are the agent's prompts and get triggered when a decision is being made
The ecosystem is built on a co-ownership model, where participants can own virtual assets and AI personas. This incentivizes active participation and ensures that the benefits of the network are shared, creating a collaborative and dynamic environment for all involved.
Hands-On Example
We're building a Bluesky Social Media Bot
To illustrate the capabilities of a virtual agent, let's create a practical example.
We will build a Python bot that uses the Bluesky Social API to automatically like and comment on content. This bot demonstrates a simple form of a virtual agent that could be used for "mass online engagement to spread it and shape narratives, promote agendas, or manage reputation"
We will use the official atproto Python library to interact with the Bluesky API.
#
# A Python script to create a Bluesky social media bot.
# This bot demonstrates how a virtual agent could interact with a social media platform
# to like and comment on posts based on specific criteria.
#
# This example uses the `atproto` Python library, which is the official SDK for the Bluesky API.
# You can install it with: `pip install atproto`
#
import os
import time
from datetime import datetime
from atproto import Client, models
# --- Configuration and Authentication ---
# IMPORTANT: Replace these with your actual Bluesky credentials.
# It is highly recommended to use environment variables for security.
# For example:
# BLUESKY_IDENTIFIER = os.environ.get("BLUESKY_IDENTIFIER")
# BLUESKY_PASSWORD = os.environ.get("BLUESKY_APP_PASSWORD")
#
# For testing purposes, you can hardcode them here, but this is not secure.
BLUESKY_IDENTIFIER = "your-handle.bsky.social"
BLUESKY_PASSWORD = "your-app-password"
def create_bluesky_client():
"""Initializes and authenticates the Bluesky client."""
client = Client()
try:
print("Attempting to log in to Bluesky...")
client.login(BLUESKY_IDENTIFIER, BLUESKY_PASSWORD)
print("Login successful.")
return client
except Exception as e:
print(f"Error during login: {e}")
return None
# --- Core Bot Logic ---
def find_and_engage(client, query, count=10):
"""
Finds posts based on a query and engages with them (likes and comments).
Args:
client: The authenticated Bluesky client.
query (str): The search query to find posts.
count (int): The number of posts to fetch and potentially engage with.
"""
print(f"\nSearching for posts with query: '{query}'...")
try:
# Search for posts by text
response = client.app.bsky.feed.search_posts(q=query, limit=count)
# Check if the response contains posts
if not response.posts:
print(f"No posts found for query: '{query}'.")
return
print(f"Found {len(response.posts)} posts. Starting engagement process...")
for post in response.posts:
# We'll only engage with posts that are recent
post_time = datetime.strptime(post.indexedAt, "%Y-%m-%dT%H:%M:%S.%fZ")
time_difference_minutes = (datetime.utcnow() - post_time).total_seconds() / 60
# Criteria: only engage with posts less than 60 minutes old
if time_difference_minutes > 60:
print(f"Skipping post by {post.author.handle} because it is too old.")
continue
try:
# 1. Like the post
print(f"Liking post by {post.author.handle}...")
client.like(uri=post.uri, cid=post.cid)
print("Post liked successfully.")
# Wait for a moment to avoid rate limiting
time.sleep(2)
# 2. Comment on the post
comment_text = f"This is an interesting take on {query}!"
print(f"Commenting on post by {post.author.handle}...")
# Create a link back to the original post for the comment
comment_record = models.AppBskyFeedPost.Main(
text=comment_text,
reply=models.AppBskyFeedPost.ReplyRef(
parent=models.ComAtprotoRepoStrongRef.Main(uri=post.uri, cid=post.cid),
root=models.ComAtprotoRepoStrongRef.Main(uri=post.uri, cid=post.cid)
)
)
client.post(text=comment_text, reply_to=post)
print("Comment posted successfully.")
except Exception as e:
print(f"Could not engage with post from {post.author.handle}: {e}")
# Add a longer sleep between engaging with different posts
time.sleep(10)
except Exception as e:
print(f"An error occurred during the search or engagement process: {e}")
# --- Main Execution Loop ---
def main():
"""The main function to run the bot."""
client = create_bluesky_client()
if not client:
print("Bot cannot run without a successful login.")
return
# A list of keywords to search for
keywords = ["AI", "virtual reality", "decentralized finance", "blockchain"]
while True:
try:
for keyword in keywords:
find_and_engage(client, keyword, count=10)
# Wait before starting the next keyword search
print(f"\nWaiting for 5 minutes before the next search cycle...")
time.sleep(300) # Sleep for 5 minutes
except KeyboardInterrupt:
print("\nBot stopped by user. Exiting.")
break
except Exception as e:
print(f"An unexpected error occurred in the main loop: {e}")
# Wait a bit longer before retrying in case of a major error
time.sleep(600)
if __name__ == "__main__":
main()
Let's integrate the game SDK to make this bot an autonomous onchain agent.
Unlike a basic script that just posts messages, this bot will leverage the Virtuals GAME framework to make decisions and act autonomously. By the end, you'll have a foundation for building a truly smart and responsive social agent Which consists of a persona, a goal, and a set of tools for an AI. The AI, or agent, uses this information to create a plan and execute it. We'll use this framework to give our Bluesky bot a "brain," allowing it to understand the context of posts and decide how to respond.
The key to this integration is treating the Bluesky bot's actions—like replying to a post—as a "tool" that the GAME agent can use.
The following Python script demonstrates how to connect a Bluesky bot to the GAME framework. It sets up an agent with a goal to "engage in meaningful conversation," and then it continuously monitors the Bluesky feed for new posts. When a post is found, it sends the content to the GAME agent, which decides whether and how to reply.The code is heavily commented to help you understand each step.
# --- IMPORTS AND SETUP ---
import os
import time
from datetime import datetime
from atproto import Client
from game_sdk.game.agent import Agent, WorkerConfig
from game_sdk.game.custom_types import Function, Argument, FunctionResultStatus
# Load environment variables for credentials and API keys
# NEVER hardcode credentials in your script!
BSKY_IDENTIFIER = os.environ.get("BSKY_IDENTIFIER")
BSKY_PASSWORD = os.environ.get("BSKY_PASSWORD")
VIRTUALS_API_KEY = os.environ.get("VIRTUALS_API_KEY")
# --- INITIALIZE BLUESKY CLIENT ---
print("Attempting to connect to Bluesky...")
try:
bsky_client = Client()
bsky_client.login(BSKY_IDENTIFIER, BSKY_PASSWORD)
print("Successfully logged into Bluesky!")
except Exception as e:
print(f"Failed to log into Bluesky: {e}")
exit()
# --- DEFINE GAME FRAMEWORK TOOL ---
# This function will be called by the GAME agent to reply to a post.
# It acts as a "tool" in the agent's toolkit.
def reply_to_post(parent_uri: str, parent_cid: str, text: str):
"""
Replies to a Bluesky post.
Args:
parent_uri (str): The URI of the post to reply to.
parent_cid (str): The CID of the post to reply to.
text (str): The text of the reply.
"""
try:
# Create the reply object with the parent post details
reply_ref = {
"root": {"uri": parent_uri, "cid": parent_cid},
"parent": {"uri": parent_uri, "cid": parent_cid}
}
# Send the reply to Bluesky
bsky_client.send_post(text, reply_ref=reply_ref)
print(f"Agent successfully replied to post with text: '{text}'")
return FunctionResultStatus.DONE, "Reply sent successfully.", {}
except Exception as e:
print(f"Failed to send reply: {e}")
return FunctionResultStatus.ERROR, f"Failed to send reply: {e}", {}
# Create a Function object for the GAME framework
# This describes the `reply_to_post` function to the agent
reply_tool = Function(
fn_name="reply_to_post",
fn_description="Replies to a post on the Bluesky social network.",
args=[
Argument(name="parent_uri", type_="string", description="The URI of the post being replied to."),
Argument(name="parent_cid", type_="string", description="The CID of the post being replied to."),
Argument(name="text", type_="string", description="The text of the reply.")
]
)
# --- INITIALIZE GAME FRAMEWORK AGENT ---
# Define the agent's personality and goal
agent_persona = "You are a helpful and friendly social media bot. Your goal is to engage in positive conversations and provide useful information."
agent_goal = "Reply to posts on Bluesky to foster a sense of community and provide helpful, relevant responses."
# Configure the agent with its worker and tools
worker_config = WorkerConfig(
description=agent_persona,
# The `tools` list is where we connect our custom Python function
tools=[reply_tool]
)
game_agent = Agent(
api_key=VIRTUALS_API_KEY,
agent_description=agent_goal,
worker_configs=[worker_config]
)
# --- BOT'S MAIN LOOP ---
# The bot will continuously check the feed and send new posts to the agent.
# This loop simulates the agentic behavior.
print("Starting Bluesky bot main loop...")
# Keep track of the last post we saw to avoid processing duplicates
last_post_uri = None
while True:
try:
# Get the latest posts from the user's feed
# For a full-featured bot, you would likely use `get_timeline` and filter
# or listen for specific mentions. For this example, we'll check the main feed.
feed = bsky_client.get_timeline(limit=1)
latest_post = feed.feed[0].post.record
post_uri = feed.feed[0].post.uri
post_cid = feed.feed[0].post.cid
# Check if we've already processed this post
if post_uri != last_post_uri:
print(f"New post found: {latest_post.text}")
# Prepare the input for the GAME agent.
# The agent will use this "world state" to make its decision.
input_context = {
"post_text": latest_post.text,
"author": feed.feed[0].post.author.handle,
"post_uri": post_uri,
"post_cid": post_cid,
"bot_handle": BSKY_IDENTIFIER
}
# Let the agent make a decision. This is where the magic happens!
# The agent will decide if it needs to reply and what to say.
response = game_agent.run(inputs=input_context)
# The `response` object contains the agent's plan and actions.
# We will use this to execute the reply.
print("Agent's plan:", response.plan)
print("Agent's actions:", response.actions)
# Since the agent's action is to call our `reply_to_post` tool,
# we can find the arguments it decided on and call our function manually.
if response.actions and response.actions[0].tool_name == "reply_to_post":
action_args = response.actions[0].tool_parameters
reply_to_post(
parent_uri=action_args.get("parent_uri"),
parent_cid=action_args.get("parent_cid"),
text=action_args.get("text")
)
# Update the last post URI
last_post_uri = post_uri
# Wait a bit before checking for new posts again to avoid API rate limits
time.sleep(60)
except Exception as e:
print(f"An error occurred in the main loop: {e}")
time.sleep(60)
In order to register for the hackathon you need to have an idea for an agent and a tokenomics schema to launch your social community, if you are a dev and you like this codebase please reach out to me, the price is juicy and the Virtuals traders community is literate and driven.
We can do wonders over there!