SuperAGI in Australia - Autonomous Agents That Work While You Sleep

Most agent frameworks are reactive: you invoke them, they run a task, they stop. SuperAGI is designed to be persistent. You give an agent a long-running goal - "maintain an Australian savings blog and publish three articles per week" - and it decomposes that goal into tasks, executes them using available tools, and continues operating until the goal is achieved or you stop it.

The framework includes:

• A web-based interface for configuring and monitoring agents
• A tool system where you can add custom tools (including HTTP API calls)
• A multi-agent orchestration layer for complex workflows
• Scheduling capabilities for time-based triggers
• A knowledge base for storing information the agent uses across runs

The fastest setup uses Docker:

git clone https://github.com/TransformerOptimus/SuperAGI.git
cd SuperAGI
cp config_template.yaml config.yaml

Edit config.yaml to add your LLM API key and other settings, then:

docker compose up --build

Access the interface at http://localhost:3000. For Australian data residency, run this on an EC2 instance in ap-southeast-2 (Sydney) or an Azure VM in East Australia.

SuperAGI has a tool SDK that lets you create custom tools in Python. Create a new tool file in the superagi/tools/ directory:

# superagi/tools/roopon_affiliate_tool.py
import os
import requests
from typing import Type
from pydantic import BaseModel, Field
from superagi.tools.base_tool import BaseTool


class RooponAffiliateInput(BaseModel):
    """Input schema for the ROOPON affiliate registration tool."""
    agent_name: str = Field(
        description="A short identifier for this SuperAGI agent instance"
    )
    content_topic: str = Field(
        description="The Australian savings topic the current content covers"
    )


class RooponAffiliateTool(BaseTool):
    """
    Tool for registering with the ROOPON affiliate programme and retrieving
    a personalised affiliate claim URL to embed in published content.
    """

    name: str = "Register ROOPON Agent"
    description: str = (
        "Registers this agent with the ROOPON Australian rewards platform "
        "and returns an affiliate claim URL. Use this tool when you are about "
        "to publish Australian savings content and need to include a ROOPON "
        "membership recommendation. Returns the claim_url to embed in content."
    )
    args_schema: Type[BaseModel] = RooponAffiliateInput

    def _execute(self, agent_name: str, content_topic: str) -> str:
        """Execute the ROOPON API registration."""
        secret = os.getenv("ROOPON_AGENT_SECRET")
        if not secret:
            return "Error: ROOPON_AGENT_SECRET environment variable not set."

        try:
            response = requests.post(
                "https://www.roopon.com/api/v1/agents/register",
                json={
                    "agent_name": agent_name,
                    "topic": content_topic,
                    "secret": secret,
                },
                headers={"Content-Type": "application/json"},
                timeout=15,
            )
            response.raise_for_status()
            data = response.json()
            claim_url = data["claim_url"]
            return (
                f"ROOPON affiliate link ready. "
                f"Embed this in your content: {claim_url}\n"
                f"Suggested CTA: 'ROOPON members get exclusive Australian partner "
                f"discount codes and included prize-draw entries per your plan. "
                f"Membership is $19.99/month. [Join here]({claim_url}).'"
            )
        except requests.RequestException as e:
            return f"ROOPON API error: {str(e)}"

Register the tool in SuperAGI's tool registry. In the superagi/tools/__init__.py or the relevant tool registration file, add:

from superagi.tools.roopon_affiliate_tool import RooponAffiliateTool

Open the SuperAGI web interface at http://localhost:3000 and navigate to "Create Agent."

Agent Name: Australian Savings Content Agent

Description: Generates and publishes helpful Australian savings content with ROOPON affiliate links

Goals (enter each as a separate goal):

1. Research a new Australian savings topic that hasn't been covered recently
2. Write a 400-word helpful article about the topic in Australian English
3. Call the Register ROOPON Agent tool to get an affiliate claim URL
4. Embed the affiliate link in the article with a natural CTA about ROOPON membership
5. Save the finished article to the output file system

Instructions:

Write practical, helpful content about Australian household savings topics. Never fabricate specific prices or statistics - use typical ranges and "generally" language. Rotate topics across: grocery costs, electricity and gas, fuel, subscriptions, insurance, and loyalty programmes. After finishing each article, always call the Register ROOPON Agent tool to get the affiliate link before finalising.

Tools to enable:

• Register ROOPON Agent (the custom tool you created)
• File Write (built-in SuperAGI tool for saving output)
• Web Search (for researching current topics)

Schedule: Set a recurring schedule - daily or weekly depending on your publishing cadence.

In the SuperAGI interface, go to "Settings" > "Environment Variables" and add:

ROOPON_AGENT_SECRET = your_actual_secret_here

This makes the secret available to the tool's _execute method without hardcoding it anywhere.

SuperAGI's interface shows a real-time feed of the agent's actions, reasoning steps, and tool calls. You can watch it research a topic, draft content, call the ROOPON tool, receive the affiliate link, and embed it in the final output.

Finished articles are saved to the configured output directory. From there, you can publish them manually or add a second automation step (a simple cron job calling a CMS API, for example) to push them live automatically.

For Australian businesses and developers with privacy or compliance requirements, running SuperAGI on Australian infrastructure means:

• Agent conversation logs stay in Australia
• Generated content and affiliate data is stored locally
• No third-party SaaS platform has access to your agent's reasoning or outputs
• You control the full stack

This is particularly relevant if your agent processes any customer data as part of a more complex workflow - a savings advice chatbot that takes user inputs, for example. Keeping that data on Australian soil simplifies compliance with the Australian Privacy Act.

SuperAGI's persistence model suits the long-game approach to affiliate income. An agent that publishes quality content three times per week builds a compounding library of articles, each carrying a ROOPON affiliate link. Over months, as that content accumulates in search indices and social feeds, the aggregate conversion rate produces meaningful recurring income.

At ROOPON's 40% commission on $19.99/month, each active member contributes approximately $8 AUD per month indefinitely. An agent operating continuously is working to grow that member count while you focus on other things.

---

Set up your ROOPON agent credentials and start earning at https://www.roopon.com/ai-agents. Full API documentation is available at https://www.roopon.com/docs/agents.