Memetoken Scout Alert System - Confirm & Copy Final Agent Code

Describe

Describe your task

Refine

Refine the plan

SubAgents

Review all agents

Deploy

Deploy your agent

Review Final Agent Copy

Expand

[
  {
    "taskID": 226,
    "semanticTitleOfTask": "GMGN.ai Token Data Extractor",
    "taskDescription": "This task scrapes GMGN.ai to gather comprehensive token data (liquidity, 24h volume, age in hours, holder count, and contract address). It returns the data in a structured format and handles pagination if present.",
    "inputDescription": "The main inputs are: (1) the GMGN.ai tokens listing URL (VARIABLE1) to scrape, and (2) a list of desired metrics to collect (VARIABLE2). The scraper must handle pagination, gather the required fields for each token, and store them in a structured dictionary or JSON format.",
    "inputRequired": ["VARIABLE1","VARIABLE2"],
    "outputDescription": "Provides raw token data in a structured dictionary or JSON with keys for contract address, liquidity, volume (24h), age (in hours), and holder count.",
    "outputName": "raw_token_data",
    "promptInstruction": "You are a web scraping specialist. Create a Python script that extracts token data from GMGN.ai. For each token, extract liquidity, 24h volume, token age in hours, holder count, and contract address. Handle pagination if present. Format the data as a structured dictionary with contract address as the key. Include error handling for failed requests and return the data."
  },
  {
    "taskID": 190,
    "semanticTitleOfTask": "Token Metrics Filter and Validator",
    "taskDescription": "This task filters the raw token data to retain only tokens that meet the thresholds: liquidity under 100,000, 24h volume under 250,000, token age at least 24 hours, and holder count at most 300. Tokens not meeting these requirements are dropped.",
    "inputDescription": "Receives the raw token data in a structured dictionary or JSON (raw_token_data), along with the specific filter criteria (VARIABLE3). The task evaluates each token according to the thresholds and discards those that fail any of them.",
    "inputRequired": ["raw_token_data","VARIABLE3"],
    "outputDescription": "Outputs a filtered dictionary or JSON containing only tokens meeting all specified thresholds. Includes a timestamp indicating when the filtering was performed.",
    "outputName": "gmgn_filtered_tokens",
    "promptInstruction": "You are a data filtering specialist. Create a Python function that processes the input token data and applies these exact filtering criteria: liquidity < 100,000, 24h volume < 250,000, token age >= 24 hours, and holder count <= 300. The function should remove any token failing a single criterion. Maintain the same structure, add a timestamp, and return the final dictionary."
  },
  {
    "taskID": 226,
    "semanticTitleOfTask": "Rugcheck: Scrape Risk Rating, Score, Verification & Lock Status",
    "taskDescription": "Scrapes rugcheck.xyz for each token's contract address to gather the overall safety score, risk rating category (e.g., Good, Excellent), liquidity lock status, and contract verification status. Produces a structured data object containing these results for each token.",
    "inputDescription": "A list of tokens containing their contract addresses and associated metadata from the previous subagent (gmgn_filtered_tokens). For each token, we must visit rugcheck.xyz/scan/<contractAddress> to retrieve the rating data.",
    "inputRequired": ["gmgn_filtered_tokens"],
    "outputDescription": "A collection of tokens with appended rugcheck.xyz rating details, including overall safety score, risk category, liquidity lock status, and contract verification status.",
    "outputName": "raw_rugcheck_ratings",
    "promptInstruction": "You are a web scraping specialist. For each provided contract address, visit rugcheck.xyz/scan/CONTRACT_ADDRESS, and extract the following data points: (1) Overall Safety Score (numeric), (2) Risk Rating Category (text), (3) Liquidity Lock Status (true/false), (4) Contract Verification Status (true/false). Return the data in a structured format keyed by contract address."
  },
  {
    "taskID": 190,
    "semanticTitleOfTask": "Filter Tokens Based on Rugcheck Rating Threshold",
    "taskDescription": "Processes rugcheck ratings to keep tokens meeting the 'Good' or higher risk rating threshold, plus additional criteria regarding safety score, liquidity lock, and contract verification. Discards tokens failing these conditions.",
    "inputDescription": "Two inputs: (1) The previously scraped rugcheck rating data (raw_rugcheck_ratings), (2) The original metadata from the filtered tokens (gmgn_filtered_tokens). The algorithm checks if the risk rating category is at least Good, the overall safety score is ≥ 70, and that both liquidity lock and contract verification are true.",
    "inputRequired": ["raw_rugcheck_ratings","gmgn_filtered_tokens"],
    "outputDescription": "A refined list of tokens that pass the rating threshold. Each token retains its original metadata, augmented by the confirmed rugcheck rating details. All tokens that do not meet criteria are excluded.",
    "outputName": "good_rated_tokens",
    "promptInstruction": "You are a data filtering specialist. Review the rugcheck ratings for each token. For any token where: (1) Risk Rating Category is 'Good' or 'Excellent', (2) Overall Safety Score ≥ 70, (3) Liquidity Lock Status is true, and (4) Contract Verification Status is true, include that token with its metadata in the output dictionary keyed by contract address. Discard all others."
  },
  {
    "taskID": 226,
    "semanticTitleOfTask": "Fetch Twitter Metrics from Tweetscout.io",
    "taskDescription": "Using each token's Twitter handle, this task scrapes tweetscout.io to retrieve the token's social media score and the top 20 influencer accounts following the project. The extracted data is delivered in a JSON structure.",
    "inputDescription": "This task requires a list of tokens, each containing a contract address and Twitter handle, as well as the tweetscout.io URL pattern. For each token, the script navigates to the specified endpoint to gather the relevant metrics.",
    "inputRequired": ["good_rated_tokens"],
    "outputDescription": "The extracted data includes the token's social media score as a numerical value, along with an array of up to 20 influencer accounts and related metadata. It is returned as structured JSON without modification to the raw values.",
    "outputName": "raw_twitter_data",
    "promptInstruction": "Using the provided Twitter handle, navigate to tweetscout.io/[handle] to extract the token’s social score and the top 20 influencers following the project. Capture each influencer’s username, follower count, and verification status. Return these results in JSON format without any modifications."
  },
  {
    "taskID": 190,
    "semanticTitleOfTask": "Merge Twitter Data with Token Information",
    "taskDescription": "This task merges the newly retrieved Twitter data with each token’s existing fields (contract address, liquidity, volume, age, holders, etc.) into a standardized JSON object. A timestamp field is added to indicate when this data was combined.",
    "inputDescription": "This task needs the original list of tokens (good_rated_tokens) and the results from the Twitter scraping task (raw_twitter_data). Each token entry is matched with its corresponding Twitter metrics, creating a finalized JSON structure.",
    "inputRequired": ["good_rated_tokens","raw_twitter_data"],
    "outputDescription": "The output is a consolidated JSON array of tokens, each containing the original data fields plus the newly added social score, top 20 influencers, and a timestamp. Missing data fields are recorded as null values while preserving the integrity of all raw data.",
    "outputName": "tokens_with_twitter_insights",
    "promptInstruction": "Create a structured JSON object for each token, incorporating the original token data plus social media metrics. Ensure numerical values maintain their original precision. Include a 'timestamp' field to indicate when the merge occurred, and use null values for any missing data."
  },
  {
    "taskID": 190,
    "semanticTitleOfTask": "Generate Complete Python Automation Script",
    "taskDescription": "This task uses a large language model to create a comprehensive Python script that integrates GMGN.ai data collection, rugcheck.xyz risk analysis, tweetscout.io Twitter analysis, and Telegram notifications into a single automated workflow.",
    "inputDescription": "It requires the token filter criteria (token_criteria), the GMGN.ai URL or API endpoint (gmgn_endpoint), the rugcheck.xyz endpoint (rugcheck_endpoint), the tweetscout.io endpoint (tweetscout_endpoint), the Telegram bot token (telegram_bot_token), and the code requirements (code_requirements). These elements guide the generation of the final script.",
    "inputRequired": [
      "token_criteria",
      "gmgn_endpoint",
      "rugcheck_endpoint",
      "tweetscout_endpoint",
      "telegram_bot_token",
      "code_requirements"
    ],
    "outputDescription": "A single Python script that, when executed, retrieves tokens from GMGN.ai, filters them, checks rugcheck.xyz rating, acquires Twitter data from tweetscout.io, and sends notifications via Telegram if the tokens meet all specified criteria. It also provides data management, scheduling, and error handling features.",
    "outputName": "final_automation_script",
    "promptInstruction": "As an expert Python developer, create a comprehensive script that: 1) Scrapes GMGN.ai for tokens, filtering by liq<100k, vol<250k, age≥24h, holders≤300 2) Checks rugcheck.xyz rating≥ Good 3) Retrieves social and influencer data from tweetscout.io 4) Stores data in SQLite with one-month retention 5) Sends Telegram alerts (limit 100/day). Add robust error handling, 60-min scheduling, and detailed comments."
  },
  {
    "taskID": 226,
    "semanticTitleOfTask": "Extract & Compare Updated Token Metrics from GMGN.ai",
    "taskDescription": "This task uses skill #226 to fetch updated token metrics (liquidity, volume, holders, timestamp) from GMGN.ai for each previously alerted token. It then compares these metrics with stored historical data against thresholds (liquidity < 100,000, volume < 250,000, holders ≤ 300) to detect any changes or below-threshold values.",
    "inputDescription": "Requires: (1) a list of previously alerted tokens (previously_alerted_tokens) with historical metrics (historical_metrics), (2) threshold dictionary (thresholds), and (3) GMGN.ai URL details (gmgn_URL). The updated metrics will be checked against the thresholds and any changes since last check will be flagged.",
    "inputRequired": ["previously_alerted_tokens","historical_metrics","thresholds","gmgn_URL"],
    "outputDescription": "Returns updated_token_metrics, which is a structured dataset of new token metrics plus flags indicating which tokens have changed or fallen below threshold.",
    "outputName": "updated_token_metrics",
    "promptInstruction": "You are a data extraction specialist. Extract the following metrics for the provided token addresses from GMGN.ai: liquidity, volume, holder count, and timestamp. Format the data as a dictionary with the contract address as the key. Compare each metric against these thresholds: liquidity < 100,000, volume < 250,000, holders ≤ 300. Flag any metrics that have fallen below these thresholds since the last check. Return only tokens that have experienced changes in their metrics."
  },
  {
    "taskID": 190,
    "semanticTitleOfTask": "Generate Alert Messages for Below-Threshold Tokens",
    "taskDescription": "This task uses skill #190 to produce a concise, Telegram-ready alert message for tokens that have fallen below thresholds since the last check. It includes the token name, contract address, which metrics declined, previous vs. current values, timestamp, and an urgent flag for significant drops.",
    "inputDescription": "Requires the updated_token_metrics from the previous task, along with their previous metrics (historical_metrics) and threshold values (thresholds), to accurately report which tokens have dropped below threshold or changed significantly.",
    "inputRequired": ["updated_token_metrics","historical_metrics","thresholds"],
    "outputDescription": "Generates alert_message_text containing one or more Telegram-formatted alert messages summarizing each token’s below-threshold metrics, percentage drop, and a 30-day data retention notice.",
    "outputName": "alert_message_text",
    "promptInstruction": "You are a crypto alert message specialist. Generate a concise, Telegram-formatted alert for tokens below thresholds. Include: (1) Token name & contract address, (2) Declined metrics, (3) Previous vs current values, (4) % change, (5) Timestamp, (6) 30-day data reminder. Add spacing & emojis. For >50% drops, add an urgent notice flag."
  },
  {
    "taskID": 226,
    "semanticTitleOfTask": "Clean Up Historical Token Data Over 30 Days Old",
    "taskDescription": "This task uses skill #226 to manage and clean the token data store. It checks for token records older than 30 days based on timestamp, removes expired entries, and produces a cleanup report summarizing final metrics and reason for removal.",
    "inputDescription": "Requires full token database (token_database), current date/time (current_timestamp), and a 30-day retention threshold (retention_period). Token entries exceeding 30 days are removed, ensuring active monitoring data is preserved.",
    "inputRequired": ["token_database","current_timestamp","retention_period"],
    "outputDescription": "Outputs cleaned_token_database, a pruned dataset free of outdated token records, along with a structured cleanup report of removed entries, final metrics, and removal rationale.",
    "outputName": "cleaned_token_database",
    "promptInstruction": "You are a database maintenance specialist. Review the provided token database and identify all entries older than 30 days. Generate a list of entries to be removed, ensuring no active data is purged. For each token removed, create a brief summary of its metric history. Format the output as a structured cleanup report: 1) tokens removed, 2) monitoring duration, 3) final metric values, 4) reason for removal."
  },
  {
    "taskID": 226,
    "semanticTitleOfTask": "GMGN.ai Token Data Re-Scraping",
    "taskDescription": "Continuously scrapes fresh token metrics (liquidity, volume, holders, age) from GMGN.ai for previously qualified token addresses. Gathers updated data at regular intervals to keep monitoring up-to-date.",
    "inputDescription": "Receives a list of token contract addresses to track (monitored_token_list), along with their GMGN.ai resource URLs (gmgn_url_endpoints), and the original timestamp of when they were added to monitoring (original_timestamps). Uses these to scrape new data from GMGN.ai.",
    "inputRequired": ["monitored_token_list","gmgn_url_endpoints","original_timestamps"],
    "outputDescription": "Generates a dictionary or JSON structure mapping each contract address to its updated metrics—liquidity, 24h volume, holder count, token age, and the new retrieval timestamp.",
    "outputName": "updated_token_metrics_subagent6",
    "promptInstruction": "You are a web scraping specialist. Extract the following metrics from the GMGN.ai page for each token address provided: current liquidity value, 24h trading volume, total holder count, and token age in hours. Format the data as a dictionary with the contract address as the key and metrics as nested values. Include the current timestamp with each entry. Only return the structured data, no explanatory text."
  },
  {
    "taskID": 1901,
    "semanticTitleOfTask": "Token Metrics Data Structuring",
    "taskDescription": "Generate Python code that takes raw token metrics and organizes them into a structured format for each monitored token, linking current metrics with original data and timestamps.",
    "inputDescription": "Expects the raw updated_token_metrics_subagent6 from Task 226, as well as any existing data structure template. The code must organize the data by contract address, nesting metrics and timestamps appropriately, with error handling.",
    "inputRequired": ["updated_token_metrics_subagent6"],
    "outputDescription": "Outputs Python code that constructs a dictionary or JSON object. Each key is a contract address, containing nested dictionaries for current metrics, original metrics, the initial monitoring timestamp, and the last update timestamp.",
    "outputName": "structured_token_data",
    "promptInstruction": "Generate Python code that takes raw token metrics and organizes them into a structured format. The code should create a dictionary where each token address is a key containing nested dictionaries for: current metrics, original metrics, initial monitoring timestamp, and last update timestamp. Include error handling for missing or malformed data. Return only the functioning code, no explanations."
  },
  {
    "taskID": 1902,
    "semanticTitleOfTask": "Token Metrics Threshold Analysis",
    "taskDescription": "Creates Python code to compare each token's current metrics (liquidity, volume, holders) against standard thresholds. Flags tokens that fall below thresholds and calculates percentage changes for each metric.",
    "inputDescription": "Requires the structured_token_data from the previous task and a set of threshold values (threshold_values). The code checks liquidity < 100,000, volume < 250,000, holders ≤ 300, flagging tokens that have degraded below these criteria.",
    "inputRequired": ["structured_token_data","threshold_values"],
    "outputDescription": "Outputs a Python function that returns a list of tokens requiring alerts, detailing their specific threshold violations, the percentage changes since last check, and any relevant notes for further handling.",
    "outputName": "threshold_comparison_results",
    "promptInstruction": "Create Python code that compares current token metrics against defined thresholds: liquidity < 100,000, volume < 250,000, holders ≤ 300. The code should flag any tokens that have fallen below these thresholds since their last check. Calculate the percentage change for each metric. Return a function that takes the structured token data as input and outputs a list of tokens requiring alerts, including their specific threshold violations and change percentages."
  },
  {
    "taskID": 1903,
    "semanticTitleOfTask": "Alert Message Generation",
    "taskDescription": "Generates detailed alert messages for tokens that have fallen below thresholds. Includes metrics that failed, percentage change, monitoring duration, and a risk level assessment.",
    "inputDescription": "Requires the threshold_comparison_results from Task 1902. Each entry indicates a token with metrics below acceptable limits. The messages must be formatted clearly, referencing relevant details and changes.",
    "inputRequired": ["threshold_comparison_results"],
    "outputDescription": "Produces an array of formatted alert messages that detail the failing metrics for each token, the magnitude of the drop, time since first monitoring, and a risk assessment level.",
    "outputName": "alert_messages",
    "promptInstruction": "Create detailed alert messages for tokens that have fallen below thresholds. Include: token address, specific metrics that failed, percentage change since last check, time since first monitoring started, and a risk level assessment (High/Medium/Low) based on the severity of threshold violations. Format the message to be clear and readable in Telegram. Return only the formatted message text."
  },
  {
    "taskID": 1904,
    "semanticTitleOfTask": "Telegram Bot Integration",
    "taskDescription": "Generates Python code that establishes a connection with the Telegram bot using the provided API token and sends alert messages. Includes error handling, retries on failure, and rate limit compliance.",
    "inputDescription": "Requires the alert_messages from Task 1903, the Telegram bot's API token (telegram_bot_api_token), and the endpoint URL (telegram_bot_url). The code must handle batch notifications, log successful sends, and handle potential errors or rate-limiting.",
    "inputRequired": ["alert_messages","telegram_bot_api_token","telegram_bot_url"],
    "outputDescription": "Outputs a Python function for sending messages through the Telegram bot. On successful execution, returns a status or log entry indicating the success or failure of notifications.",
    "outputName": "telegram_notification_status",
    "promptInstruction": "Generate Python code that handles Telegram bot communication. Include functions for: establishing bot connection using provided API token, formatting and sending alert messages, handling send failures with retries, and logging successful notifications. The code should be able to batch multiple alerts if needed and respect Telegram's rate limits. Return only the functioning code."
  },
  {
    "taskID": 1905,
    "semanticTitleOfTask": "Token History Management",
    "taskDescription": "Generates Python code that manages the token monitoring dataset, identifying entries older than 30 days and removing them. Ensures data integrity, logs removed tokens, and maintains an optimized data structure.",
    "inputDescription": "Requires the structured_token_data from earlier tasks, along with a 30-day age threshold. Uses recorded timestamps to detect which tokens exceed the monitoring duration limit, removing them from active tracking and updating logs.",
    "inputRequired": ["structured_token_data"],
    "outputDescription": "Outputs a Python function that purges tokens older than 30 days, updates the active monitoring dataset, and logs the removed entries. Maintains an accurate and efficient tracking system.",
    "outputName": "cleaned_token_dataset",
    "promptInstruction": "Create Python code that manages the token monitoring dataset. Include functions for: identifying and removing tokens older than 30 days, updating the active monitoring list, maintaining a log of removed tokens, and optimizing the data structure for memory efficiency. Include error handling and data validation. Return only the functioning code, no explanations."
  }
]

Happy? Now Copy-Paste To Proceed...

BACK TO SUBAGENTS

COPY TO CLIPBOARD