A Fragmented Experience

In today’s crypto environment, especially on Solana, most token discovery and trading relies on rapid attention cycles. Users chase launches, monitor charts, follow snipers, and attempt to decode blockchain behavior in real time. But the process to gather this information is scattered across multiple tools and platforms.

To understand even the basics of a token’s health, users often switch between:

• Birdeye or Dexscreener for price and volume

• Solscan for transaction logs and holders

• Pump.fun to verify launch status

• Twitter or Telegram to track social interest

• Manually examining wallets and deployers

This creates friction, slows decision-making, and leaves most users relying on speculation or copying others. By the time someone has pieced together all the relevant data, it is usually too late.

The Trader’s Real Needs

What users truly want to know is not just the token price or chart movement. They want answers to specific questions that help them evaluate risk and opportunity. Questions like:

• Who owns this token?

• Was it fair, or botted at launch?

• Is the deployer selling?

• Are fresh wallets entering or exiting?

• How much of the supply is locked in suspicious bundlers?

These are not questions a chart can answer. They require interpretation of raw blockchain activity, recognition of behavioral patterns, and access to deeper token metadata.

Why Other Tools Fall Short

Most current tools show raw data but do not explain what it means. For example, you might see 80 percent of a token held by ten wallets, but without context, you cannot tell if it’s malicious or just early supporters. You might see volume spike, but not know whether it came from new holders or old wallets offloading.

There are no tools today that connect these dots automatically and explain the implications like a human would. Even experienced traders spend hours doing this kind of research by hand.

We built Forge to automate and interpret this process, using AI to make blockchain readable and insightful.

Our Core Idea

Forge exists because we believe the blockchain needs a layer of explanation. Something that translates complex wallet interactions, token mechanics, and market behaviors into structured insights that even a beginner can understand.

We are not trying to compete with charting tools. We are building the layer above them — a reasoning interface. Forge does not just pull token data. It reads it, understands it, and replies with clarity. Just like asking a smart analyst for a breakdown.

This is not just about convenience. It is about creating a new way to interface with the blockchain. One that respects the intelligence of its users and makes trading feel more informed, more confident, and more fair.

Forge would not work without context. Asking “is this token safe” or “who’s buying this meme” means nothing if the AI doesn’t know what you’re pointing at, what’s happening on-chain right now, or what kind of response you expect. That’s where the Model Context Protocol comes in.

MCP is the foundation that turns Forge from a generic chatbot into a specialized on-chain assistant. It’s the layer that injects real-time data, filters intent, and builds structured inputs for the AI to reason with. Without MCP, Forge would just guess. With MCP, it becomes sharp, focused, and useful.

🔍 What MCP Does

When a user asks a question in Forge, MCP kicks in instantly. It:

• Identifies what type of question is being asked

• Checks what on-chain data is relevant

• Gathers facts from Forge’s indexers and agents

• Builds a prompt with the current context injected

• Sends that structured input to the AI model

It’s not just about having data. It’s about knowing which data matters, and how to phrase it so the model gives the right kind of response.

🧱 Why MCP Is Needed

AI models like GPT can sound smart, but they don’t “know” anything about the blockchain unless you tell them exactly what to look at. They have no memory of block height, LP status, or sniper wallet movements.

Forge solves that by using MCP to inject context like:

• “Token X just launched 2 minutes ago with 30 SOL LP”

• “Deployer has created 4 tokens this week, all rugged”

• “Wallet Y bought at launch and sold in 45 seconds”

By writing this into the prompt behind the scenes, the model no longer has to hallucinate. It now works with clean, factual, up-to-the-second context.

🧠 Context Types

MCP supports several types of context injection depending on what the user is asking:

1. Token Context – Market cap, LP size, age, deployer reputation, holder count

2. Wallet Context – Balance, buy/sell behavior, known sniper or not, related wallets

3. LP Context – Burned or not, depth, lock duration, LP-to-MC ratio

4. Telegram Context – What group a deployer or buyer recently joined

5. Historical Context – Previous events tied to the address or token

Each type is optional, and only injected when relevant. This keeps the AI focused and avoids cluttering the prompt with noise.

🧩 MCP Pipeline: Start to Finish

Here’s what happens from the moment a user types a question:

1. Message Received User types something like “Is $DUCK safe?”

2. Intent Classification MCP tags this as a token safety request

3. Target Identification It looks at recent token launches, matches $DUCK to its address and data

4. Context Injection Pulls from indexer: LP info, deployer, buys/sells, prior launches

5. Prompt Assembly Builds a structured input like: “User is asking about token $DUCK which launched 3 mins ago with 20 SOL LP. Creator has deployed 3 tokens before, 2 of which had sudden LP burns. Wallets A, B, and C bought in. Here’s the context…”

6. Model Execution The prompt is sent to the AI model

7. Response Returned Forge returns a clean, structured reply in chat, like: “$DUCK appears high risk. LP is not burned and deployer has a 66% rug rate.”

This whole flow happens in less than a second.

🛠 How It’s Built

MCP is written as a protocol layer that sits between:

• The user chat interface

• The Solana indexers and agent system

• The AI language model

It can run with different backends, not just GPT. The important part is that it knows how to inject structured data into a natural-language prompt.

It’s also modular. Developers can build their own MCP extensions with:

• New data sources (e.g. price feeds, news APIs)

• Custom prompt logic (e.g. compress data for faster responses)

• Specialized templates (e.g. red flag reports, sniper profiles)

🤖 Human-Like, But Informed

Most AI assistants in crypto are still guessing. They give fake confidence because they’re built without structured context.

Forge changes that. MCP is the reason Forge sounds like an on-chain researcher. It gives the AI the context a human would Google, check, cross-reference, and summarize — but it happens instantly, every time.

Forge isn’t a single AI. It’s a network of specialized agents, each built for a specific task. This is what makes it feel like you're chatting with an on-chain intelligence that knows exactly what it's doing.

This section explains what Forge agents are, how they’re structured, and why they’re the backbone of the entire system.

🤖 What Is a Forge Agent?

A Forge agent is a modular AI process designed to handle one specific type of blockchain intelligence task. Each agent has access to the Solana indexer, listens for key events, and can take context from MCP to return tailored insights.

Think of them like:

• One agent for watching wallets

• One for monitoring liquidity pools

• One for understanding token deployers

• One for reading Telegram sniper movement

Instead of trying to make one AI do everything, Forge spins up the right specialist — and lets that agent operate in its own optimized logic environment.

🏗 Agent Structure

Each Forge agent has 5 core components:

1. Purpose – What it’s designed to do

2. Context Hooks – What live data streams it listens to

3. Execution Logic – How it processes information

4. Prompt Template – What kind of answers it gives

5. Response Format – How it replies to users or other agents

Let’s break those down:

1. Purpose

Every agent is goal-oriented. It’s created with a specific use case in mind:

• TokenAgent → detect trends and anomalies in new tokens

• WalletAgent → track buy/sell activity, identify farming patterns

• LPAgent → monitor burn events, LP locks, tax changes

• SniperAgent → watch sniper buys, trace click-to-buy wallets

• TelegramAgent → detect KOLs joining new chats, identify signals

If your question aligns with the agent’s purpose, it will automatically be triggered.

2. Context Hooks

Agents pull their inputs from live streams of Solana blockchain data. These are the real-time hooks that feed them fresh context.

Hooks can include:

• “New Token Created”

• “LP Added or Burned”

• “Large Wallet Buy Over X SOL”

• “Telegram Join By Known Wallet”

• “Creator Renounced Contract Ownership”

Agents listen for these constantly, and some will only wake up when their hook conditions are met.

3. Execution Logic

This is the agent’s internal decision tree — how it filters data, evaluates risk, scores relevance, and decides what to say.

Examples:

• A WalletAgent might tag a wallet as a sniper if it buys 3+ tokens within 10 seconds of creation

• A TokenAgent might flag a deployer if they’ve launched 5 rugs in 24 hours

• An LPAgent might evaluate liquidity depth vs. market cap and issue a risk warning

This logic is customizable, meaning Forge devs (or users with advanced access) can tweak thresholds and behaviors.

4. Prompt Template

Each agent has a custom-written prompt structure that shapes how it speaks.

Some are formal and statistical:

“This wallet has interacted with 9 tokens in the last 3 hours, showing a clear pattern of early entry and early exit behavior.”

Others are designed to be more casual or alert-style:

“🚨 This sniper is back. Just entered a fresh meme with 30 SOL. Last seen in 3x rugs.”

The tone can be tuned depending on audience (devs vs. traders vs. analysts).

5. Response Format

Agents can:

• Return a simple answer in chat

• Open a modal with charts

• Trigger a follow-up question

• Send context to another agent for collaboration

• Push on-chain memos or flags

Forge is not just a passive assistant. Agents can trigger on-chain activity, alert teams, or even influence decision-making pipelines.

🔁 Multi-Agent Collaboration

Sometimes, a single question needs multiple agents. For example:

“Is this token safe and who deployed it?”

Forge will:

• Trigger TokenAgent → to scan the contract

• Trigger WalletAgent → to check the deployer’s behavior

• Trigger LPAgent → to verify liquidity structure

Each agent returns its part, then Forge compiles the response as if it’s a single smart analyst.

This is where Forge becomes more than a dashboard — it becomes collaborative intelligence.

🧠 Memory and State

Most agents are stateless, meaning they analyze based on real-time data without remembering past interactions. However, some advanced agents maintain short-term memory for deeper analysis chains, like:

• “What has this wallet done since I last asked?”

• “Did this token reach my alert threshold today?”

State memory is kept lightweight for performance and privacy.

🔧 Developer Notes

Advanced users and Forge integrators can:

• Build their own agents using MCP

• Override the default prompt template

• Add custom event hooks

• Push data from external sources (e.g. Twitter, Telegram, TradingView)

Forge isn’t closed. It’s a framework for AI-agent logic on-chain.

Forge wouldn't work without data. But not just any data — it needs real-time, deep, and structured access to everything happening on the Solana blockchain. Most tools rely on public APIs or post-processed stats. Forge goes deeper. It runs its own indexer built specifically for AI use cases.

This page explains how Forge gathers data from the Solana network, how it organizes that data for use by agents and MCP, and why this custom indexing approach gives Forge an edge over dashboards and other bots.

🧠 What Is an Indexer?

An indexer is a backend system that listens to every block on the blockchain, extracts useful information, and saves it in a format that can be searched instantly.

Forge’s indexer is designed to capture memecoin-scale activity. That means:

• Fresh token deployments

• Sudden LP adds and burns

• Wallet funding patterns

• Contract events

• Buy/sell flows across tokens

• Known sniper or deployer behavior

• Telegram-linked wallet movements

Everything is stored with low latency, optimized for triggering agent logic and MCP injection in real-time.

🔍 What Forge Indexes

Forge doesn’t just copy everything from the blockchain. It listens selectively for high-signal events:

Token Events

• Token creation

• Contract renounce or ownership changes

• Burn function presence

• Metadata injected (like social links or fake audits)

Liquidity Events

• LP created, burned, or modified

• Initial LP ratio

• LP lock timing

• Rug detection signals

Wallet Activity

• Wallet buys and sells (amount, timing, price)

• Sniper detection patterns

• Repeat deployers

• Wallets that fund new creations

Project Behavior

• How fast tokens hit market cap milestones

• How often deployers reuse code

• Which Telegram groups a deployer joins

• Cross-wallet clustering

All of this is tagged and stored in an optimized database, ready for agent use.

⚙️ Architecture

The indexer is built in a modular way:

• Stream Handlers – These listen to specific Solana programs (like SPL Token, Raydium, and LP routers)

• Event Filters – Only high-signal events are stored, based on pre-set triggers and custom logic

• Entity Builders – Forge reconstructs relationships between tokens, wallets, and LPs as first-class objects

This means Forge can instantly answer things like:

• “Which wallets bought this token in the first minute?”

• “Did this deployer burn LP?”

• “What’s the average lifespan of tokens from this address?”

🔄 Real-Time Sync

The indexer operates with minimal delay — usually within 0.5 to 1.5 seconds from the actual transaction.

This is why Forge can respond in chat to events that just happened:

“Token just launched, deployer has rugged 3 times today, LP was added and instantly removed.”

No need to refresh pages or wait for a daily update. It’s live.

🧠 Built for Agents

Every Forge agent pulls directly from the indexer, not from third-party APIs. That’s why responses are faster, more accurate, and richer in detail.

• TokenAgent looks at deployer patterns, social metadata, LP setup

• WalletAgent looks at how wallets fund, buy, and sell

• LPAgent listens for lock periods, burn events, and liquidity depth

Because Forge owns its index, it can inject exactly the right details into every prompt — and nothing else.

🔧 Extensible and Private

The Forge indexer can be extended to track new types of data or chains, such as:

• NFT mints and swaps

• Multi-chain deployer behavior

• Telegram and Twitter crossover signals

• Time-series patterns like sell-offs or volume spikes

It can also be deployed privately, so teams running their own Forge instance don’t need to rely on public APIs or give away their queries.

📌 Why It Matters

In crypto, seconds matter. Especially in memecoins. Forge’s indexer makes it possible to ask about something that just happened and get a full breakdown before anyone else even sees it.

This isn’t possible with dashboards that refresh every few minutes or rely on lagging RPC providers.

Forge sees the blockchain like a live organism — and makes it readable in plain English.

Forge is designed to feel like you're chatting with an AI analyst, but behind the scenes, it’s an interconnected system that combines real-time Solana data, modular agent logic, and the Model Context Protocol (MCP) to deliver responses that are accurate, fast, and actionable.

This page explains how the entire system is structured, how the components talk to each other, and why this setup allows Forge to do things that typical AI tools or analytics dashboards can’t.

🧩 Components Overview

At its core, Forge is built around 4 major architectural pillars:

1. Model Context Protocol (MCP)

2. Agent System

3. Real-Time On-Chain Indexer

4. Prompt Resolver and Execution Engine

Each of these components plays a key role in turning user questions into real insights.

1. Model Context Protocol (MCP)

MCP is the messaging layer that powers Forge’s intelligence. Think of it as the translator between user intent and on-chain execution.

• Every question goes through context injection using MCP.

• Forge evaluates who is asking, what they’re asking, and what type of data is needed.

• Based on that, it builds a custom prompt containing the real-time context from Solana, and routes it to the correct agent.

This is how Forge stays relevant to the latest blocks, wallet states, memecoin launches, and sniper movements.

2. Agent System

Forge runs on modular agents — each is like a specialized on-chain analyst. Some focus on wallets, others on liquidity, or tokens, or even Telegram activity.

Each agent has:

• Its own prompt memory

• Defined skills (e.g. LP tracking, buy/sell monitoring, wallet scoring)

• Ability to listen to events and update its internal state

Agents are stateless by default unless extended to persist certain memory across conversations.

Forge chooses which agent(s) to engage based on the user’s question — and sometimes runs them in parallel for composite queries.

3. Real-Time Solana Indexer

Forge doesn’t rely on slow APIs or outdated snapshots.

It has a custom real-time Solana indexer that tracks:

• Token deployments

• Wallet movements

• LP creation/destruction

• Market caps and volume spikes

• Telegram-linked deployer actions

This indexer ensures that every piece of context given to the AI is accurate up to the most recent block.

It’s also what lets Forge answer questions like:

“What wallets are buying tokens with a 1-minute lifespan and over 1000 SOL LP?”

4. Prompt Resolver & Execution Engine

Once the agent(s) and data are selected, Forge compiles everything into a final structured prompt.

It includes:

• Latest relevant facts

• Summarized history or metadata

• A task objective (what the user wants to know)

• Reasoning logic (e.g. highlight anomalies, find connections, detect intent)

The engine then routes this to the language model — which interprets, explains, and responds with clarity.

🔁 Data Flow (End-to-End)

Here’s a simplified walkthrough of a Forge interaction:

1. User: “Why did this token just spike in volume?”

2. MCP: Classifies intent as token analysis, selects the correct agent

3. Agent: Pulls from the indexer the LP info, wallet flow, deployer history

4. Prompt Builder: Injects real-time facts + analysis rules into a clean prompt

5. Model: Returns an answer explaining the event like an analyst

6. Forge Chat: Displays response, gives button to “Trace Wallets Involved”

🧱 Modular by Design

Each part of Forge can be extended or swapped:

• Developers can create new agents (e.g. NFT mint tracker)

• You can inject third-party APIs (e.g. sentiment feeds)

• The model layer is abstracted — Forge can run on OpenAI, Claude, or even local models

This modularity means Forge isn’t just a product. It’s a framework.

🛠 Why This Architecture Matters

Most analytics dashboards are limited to predefined queries. Most chat AIs don’t know anything about Solana. Forge bridges both.

Because of this architecture:

• Forge feels like a crypto-native analyst, not a chatbot

• It can answer complex, multi-step questions

• It’s fast, accurate, and always up to date

Forge isn’t just about raw data. It’s about how that data gets turned into language — answers that feel like they’re coming from a real analyst, not a robot. This is where the AI query handling layer comes in.

It’s the part of the system that takes the prompt built by MCP, shaped by agents, and delivers a response that makes sense, sounds human, and actually helps the user make a decision.

🧠 What Happens When You Ask a Question

Let’s say a user types:

“Is $SLAP safe?”

Here’s the full path from input to response:

1. Intent is detected – This is a token safety query

2. MCP builds the prompt – It injects current context: deployer, LP, volume, wallet flows

3. Agent executes its logic – TokenAgent filters risk signals

4. Prompt is formatted – The final prompt might say:

   "The user is asking if token $SLAP is safe. It launched 3 minutes ago with 20 SOL LP, no ownership renounced, no burn, deployer has rugged 2 tokens before, volume spiked to $90k in 2 minutes. What’s the risk profile?"

5. Prompt sent to model – This could be GPT-4, Claude, or another LLM

6. Response is returned – Forge formats it and sends it back in chat:

   “$SLAP shows clear risk signals. LP is unlocked, deployer history is suspicious, and sell pressure is already building. Trade with caution.”

This process usually takes 1 to 2 seconds.

🤖 Language Model Layer

Forge is model-agnostic. It’s designed to run with:

• OpenAI (GPT-4 or GPT-3.5)

• Anthropic (Claude)

• Local models (for private deployments)

• Any future LLM that supports plain text prompts

This means the “brain” of Forge can evolve as better models come out.

But what makes Forge different isn’t the model — it’s how it gives the model the right context, phrased the right way, every time.

📄 Prompt Construction

A Forge prompt is not a giant wall of text. It’s engineered to be:

• Minimal – only relevant info is injected

• Structured – context is labeled and grouped

• Guided – a final instruction is included to tell the AI what kind of response to give

Example:

yamlCopyEditToken Context:
- Name: SLAP
- Launched: 3 minutes ago
- LP: 20 SOL, unlocked
- Ownership: Not renounced
- Deployer: History of 2 rugs

Wallet Context:
- Early buys from sniper wallet cluster
- Sell activity already started

User Query:
“Is $SLAP safe?”

Instruction:
Analyze and return a human-readable risk profile.

This structure makes responses consistent, fast, and deeply informed.

🧠 Multi-Agent Query Resolution

Sometimes, Forge splits the question across multiple agents, each with their own micro-prompt and reply. The query handler then stitches those together into one smooth answer.

For example:

“Who deployed this and is it safe?”

• WalletAgent checks deployer history

• TokenAgent checks LP and contract setup

• LPAgent checks liquidity burn status

Each returns a part, and the query handler assembles the final response with proper phrasing.

🧪 Response Types

Forge can return answers in many formats depending on context:

• Plain text (chat-style)

• Risk score breakdowns

• Tables or bullet points

• Alerts or warnings

• Interactive follow-ups (e.g. “Trace wallets involved?”)

This flexibility is what makes it feel more like talking to a human — because the output matches the user’s intent, not just the data.

🔧 Configurable Behaviors

Admins or devs can customize:

• Prompt tone (casual, formal, technical)

• Detail level (summary or deep-dive)

• Response types (compact for mobile, full for analysts)

• Follow-up suggestions or automated triggers

This makes Forge usable by traders, teams, devs, or researchers — all from the same core system.

📌 Why It Matters

AI without context is just guessing. Blockchain data without interpretation is just noise. Forge’s query handler fuses both, giving you instant feedback that actually helps.

You don’t have to know what to ask, how to phrase it, or where to click. You just ask. Forge does the rest.

Forge is a Solana-native AI assistant that gives anyone access to deep onchain intelligence through natural language. Think of it like ChatGPT, but specifically trained to understand memecoins, snipers, liquidity trends, and wallet behaviors across Solana.

What makes Forge different is its ability to analyze blockchain activity the way a real trader thinks. It doesn't just show charts or surface token metadata — it tracks how a token behaves from the second it's deployed. Who bought it? Who sniped it? Who's still holding? Has the dev wallet sold? Forge answers these questions in seconds.

Why this matters

The memecoin space on Solana moves faster than any market. Tokens launch, pump, and die within hours. The biggest edge a trader can have is information before the rest. Forge exists to provide that edge by giving fast, interpretable answers about token health, trading activity, and wallet behaviors that usually take hours of digging.

Forge's LLM connects directly to Solana RPCs, decodes transactions, traces wallets, and returns structured, human-like answers. This means it doesn’t just “guess” or hallucinate — it retrieves real onchain data and interprets it clearly, so anyone can understand what’s going on behind a token.

How it's used

A user might ask:

• “How many wallets sniped this token in the first minute?”

• “Is the deployer wallet still holding?”

• “What % of supply is held by fresh wallets?”

• “Has this wallet launched other tokens before?”

• “Does this look like a fair launch or a farm?”

Forge responds with detailed metrics: percentages, labels, counts, and context — exactly like a smart analyst would break it down.

Forge is built to be as easy to use as chatting with a friend who knows everything about the Solana memecoin ecosystem. You don’t need to learn syntax or memorize commands — just ask naturally.

This page walks through how to ask good questions, how Forge interprets them, and what kind of responses you can expect.

Ask Anything

You can ask Forge questions like:

• “Is $BONK still active?”

• “What did this wallet just buy?”

• “Which tokens launched in the last 10 minutes?”

• “Who deployed $RUG and did they renounce?”

• “Why is this token pumping?”

• “Which wallets just sold $SLAP?”

There’s no need for specific phrasing. Forge automatically detects the intent and dispatches the right agent to answer.

Supported Question Types

Forge supports a wide range of question categories, including:

Token-Based Questions

• Safety analysis

• Deployer check

• LP burn status

• Market cap and holder count

• Sniper activity

Wallet-Based Questions

• Recent buys or sells

• Wallet history and rug involvement

• Funding source and behavior

• Other wallets it’s connected to

Time-Based Queries

• New tokens in the last X minutes

• Wallets that sold recently

• Deployer that launched today

Risk and Red Flags

• LP manipulation

• Reused deployer code

• Known rug patterns

Telegram Sniper Detection

• Wallets tied to Telegram groups

• Deployers who joined specific chats before launch

• Wallets that follow KOLs into memes

Follow-Up Questions

You can continue a conversation without repeating everything. Forge tracks context for each session.

Example:

“Who deployed $NANA?” “Are they active in any other tokens?” “What was their last rug?”

Forge understands that you're still referring to the same wallet or topic unless you change it.

Shortcuts and Suggestions

The interface includes buttons for:

• “Trace wallets involved”

• “See chart”

• “Flag deployer”

• “Show top buyers”

These are generated based on the last answer. Clicking them sends a follow-up query automatically.

How Forge Understands Intent

Under the hood, Forge uses a combination of:

• Natural language processing

• MCP-based intent classification

• Token and wallet context matching

This means it can handle vague or casual questions and still return precise answers.

Examples:

“What’s up with this token?” “Why is $DUMP trending?” “Any red flags in $WAGMI?”

Even if the question is unclear, Forge knows what to check and which agents to activate.

Tips for Better Results

While Forge is flexible, here are a few ways to get sharper answers:

• Be specific with token names or wallet addresses

• Ask one topic at a time for deeper breakdowns

• Use follow-ups to dig deeper instead of restarting the question

If a response is too shallow, you can always ask “explain deeper” or “show more detail.”

Limitations

Forge is not designed to:

• Give financial advice

• Predict exact token price movements

• Replace human due diligence

It’s a powerful assistant, not an oracle. It helps surface what’s happening, but the decision is still yours.

Forge was built to solve one thing: information overload on Solana. Memecoins, snipers, rugs, LP burns, deployer patterns — the chaos never stops. Most tools show raw data but expect you to interpret it yourself. Forge goes further by analyzing, summarizing, and explaining everything as you ask.

This page covers the most common ways people use Forge and how each use case works in practice.

Token Analysis

Goal: Quickly understand if a token is legit, risky, or already compromised.

Ask things like:

• “Is $GIBRUG safe?”

• “Did this token burn LP?”

• “What’s the deployer history?”

• “When was this created and who bought first?”

Forge checks:

• Deployer reputation

• LP setup and lock

• Market cap and supply

• Token metadata (socials, audits, etc.)

• Buyer wallets and sniper activity

It returns a natural-language breakdown that explains the token’s structure and red flags.

Wallet Tracing

Goal: Track individual wallets, see their patterns, and detect suspicious behavior.

Ask:

• “What did this wallet buy today?”

• “Has this wallet rugged before?”

• “What’s their funding source?”

• “What tokens did they sell in the last hour?”

Forge maps wallet behavior across:

• Buy and sell history

• Timing of entries and exits

• Deployments and interactions

• Relationships to other wallets

This is useful for checking a sniper, finding alts, or confirming if someone is dumping into you.

Telegram Sniper Detection

Goal: Identify wallets that act based on Telegram KOL groups.

Ask:

• “Which wallets joined this Telegram group?”

• “Did any sniper from Group A buy this?”

• “Did the deployer join a Telegram before launch?”

Forge connects:

• Telegram join events

• Deployer or buyer activity

• Time windows between join and launch

Useful when tracing KOL-backed launches or spotting coordinated pumps.

Fresh Launch Monitoring

Goal: Catch tokens as they deploy and see if they’re worth entering.

Ask:

• “What launched in the last 5 minutes?”

• “Any good-looking launches today?”

• “Which of these are safe?”

Forge looks at all new tokens and auto-sorts them by:

• Deployer score

• LP burn status

• Time since creation

• Volume, sniper entries, social metadata

You can filter by safety or risk profile and jump straight into analysis.

Rug Pattern Recognition

Goal: Detect if a deployer or token is likely to rug based on known traits.

Ask:

• “Does this look like a rug?”

• “How many rugs has this deployer done?”

• “What are rug signals in this token?”

Forge analyzes:

• LP unlock timing

• Sudden large sells

• Contract ownership

• Deploy frequency and success rate

It compares against known rug patterns and explains the result clearly.

Sniper Activity Tracking

Goal: Watch wallets that enter fast, move big money, and exit early.

Ask:

• “Which wallets just sniped this?”

• “Is this token being farmed?”

• “Any repeat snipers active?”

Forge finds:

• Wallets that entered within 10 seconds of launch

• Wallets linked to Telegram joins

• Repeat entries into new tokens

• Fast sell-offs

This helps you know when a token is already compromised or being botted.

Contract Creator Profiling

Goal: Analyze a token’s creator wallet in depth.

Ask:

• “Who made this contract?”

• “What other tokens have they launched?”

• “Any history of rugs?”

Forge returns:

• Contract deploy time and metadata

• History of previous launches

• Known links to rug clusters

• Telegram group presence

You’ll get a full profile on the person behind the token.

At first glance, Forge feels like a single unified assistant. But under the surface, each agent has its own personality, tone, and logic for how it processes data and answers questions. This design choice is intentional. It makes responses more accurate, more useful, and more human.

This page explains how agent personalities work, how prompt logic is structured, and how both can be customized depending on who’s using Forge.

What Is an Agent Personality?

An agent personality is a set of traits that shape:

• How the agent interprets data

• How it speaks to the user

• What kind of assumptions it makes

• How it frames its answers

For example:

• A TokenAgent may act like a cold risk auditor — precise, structured, and cautious.

• A WalletAgent may act like a detective — connecting dots, identifying patterns, and flagging suspicious activity.

• A SniperAgent may act like a sentry — fast alerts, short and blunt.

Each personality is tuned to match the kind of task the agent is doing and the user’s expectations.

Prompt Templates

Behind every Forge response is a prompt template — a structured format that includes:

• Context (what just happened on-chain)

• Instruction (what the agent is supposed to do)

• Voice (how the answer should sound)

• Filters (what to include or leave out)

An example prompt for the TokenAgent might look like:

vbnetCopyEditContext:
Token $RUG launched 3 minutes ago with 10 SOL LP. Ownership not renounced. LP not burned. Deployer has 5 previous launches, 4 of which were rugs. Volume has hit $20k.

Instruction:
Evaluate token safety and return a human-readable risk profile.

Voice:
Neutral, informative, short summary first, then optional detail.

The model receives this as a single input and generates a focused answer.

Tones and Styles

Forge supports multiple response tones depending on user setting or agent type:

• Formal – for analysts and dashboards

• Casual – for degen traders and fast checks

• Alert-style – short, emoji-tagged, fast warnings

• Long-form – multi-paragraph breakdowns with context

For example, the same context can return:

Formal:

"This token exhibits several red flags including an unlocked LP, a deployer with multiple past rugs, and early sell activity. Caution is advised."

Casual:

"Looks sketchy. LP not burned, same guy rugged 4 tokens last week. Big sells already hitting."

Alert-style:

"⚠️ Unlocked LP, 4x rug deployer, $20k in, early sells. High risk."

Customizing Prompt Logic

Admins or self-hosted users can change how prompts are built by modifying:

• What data points are included

• How much weight is given to each red flag

• What format the prompt uses (list, paragraph, JSON block, etc.)

• The instruction sentence (e.g. "Summarize risk" vs. "Give trading advice")

This means Forge can be tailored to different users:

• Traders who want quick reads

• Analysts who want breakdowns

• Developers who want structured data

You don’t need to touch the language model — just change the prompt logic, and the behavior changes instantly.

Multi-Agent Prompt Strategy

For complex questions, Forge may run multiple agents and merge their responses. When this happens, each agent uses its own prompt logic, but the final output is smoothed into one answer.

You can still view each agent’s reply separately, especially if you want raw data or deeper insight into how the model reasoned.

Prompt Tokens and Cost Control

In self-hosted Forge, you can control how much text is sent to the model by:

• Limiting the number of wallets or tokens included

• Compressing historical context

• Removing optional metadata

This helps reduce token usage and latency if you’re running Forge with your own OpenAI or Claude key.

Forge is built to be modular. That means you’re not limited to the default agents like TokenAgent or WalletAgent. If you have a specific use case, behavior pattern, or data stream you want to analyze, you can build your own agent from scratch.

This page covers how custom agents work, how to create them, and how they plug into the existing Forge ecosystem.

What Is a Custom Agent?

A custom agent is a user-defined module that listens for events, pulls on-chain data, and generates a response using its own logic and prompt structure.

Each agent has:

• A name and purpose

• Trigger conditions (what it listens for)

• A context builder (how it fetches data)

• A prompt template (how it speaks)

• An output method (chat, chart, modal, etc.)

You can use this to create tools like:

• A “WhaleAgent” that watches wallets moving 1000+ SOL

• A “RepeatDeployerAgent” that flags wallets launching more than 3 tokens in 24 hours

• A “KOLJoinAgent” that alerts when deployers join high-signal Telegram groups

When to Build One

Create a custom agent if:

• You’re repeating the same query pattern often

• You have unique data inputs no other agent is using

• You want a specific style of reply or workflow

• You’re working on private forks of Forge for research or trading

Agents can be used solo or combined into multi-agent chains for deeper logic.

Trigger Conditions

Agents can be triggered by:

• Token creation

• Wallet movement

• LP changes

• Time-based intervals

• External API feeds (Telegram, Twitter, etc.)

You define the logic that determines when your agent should wake up and do its job.

Context Builder

This is the part where the agent gathers the data it needs. You can pull from:

• Forge’s real-time index

• Historical data

• External APIs

• Custom tracking databases

The better your context builder, the more accurate and useful the agent’s reply will be.

Prompt Template

Just like core agents, you define how your agent speaks. You can:

• Set tone and voice

• Include structured facts

• Limit to key points or go deep

• Output in markdown, plain text, or JSON

You control the final message structure.

Output Options

Agents can return:

• A single chat message

• A detailed modal (like a token breakdown card)

• A chart or stat block

• A trigger to other agents

You can even set up cascading agents — one agent’s output becomes the input for another.

Deploying the Agent

Once your agent is written:

1. Drop it into the agents/ folder

2. Add it to the registry in the main agent loader

3. Restart the Forge backend

It will now activate automatically when its conditions are met, and show up in agent logs just like any core agent.

Testing and Debugging

During testing, you can:

• Manually simulate events to trigger the agent

• View agent logs in the console or UI

• Compare outputs with expected behavior

• Refine thresholds or context logic

Forge is built to make this fast and iterative.

Running Multi-Agent Workflows

One of the most powerful features in Forge is the ability to run multi-agent workflows — scenarios where multiple agents collaborate to answer a complex question or complete a layered analysis.

Instead of getting a single perspective, Forge can activate several agents in parallel, let them handle their parts, and then return a unified result. This makes it feel less like a chatbot and more like a research team working together.

What Is a Multi-Agent Workflow?

A multi-agent workflow is triggered when:

• A user question touches multiple areas (token + wallet + LP)

• An agent explicitly calls another agent for follow-up context

• The system detects a chain of dependencies in the logic

Each agent operates independently, using its own logic and prompt, but Forge’s query handler merges the outputs into one final message.

When They Activate

Multi-agent workflows activate automatically in questions like:

• “Is this token safe and who deployed it?”

• “What’s this wallet doing and did they rug before?”

• “Why is this token pumping and who bought in?”

Here’s how Forge breaks it down:

1. TokenAgent scans LP, contract state, volume

2. WalletAgent profiles the deployer and recent buyers

3. SniperAgent checks for known sniper activity

4. LPAgent analyzes LP structure, burn, and lock

Forge takes all the replies, filters overlap, and composes a final, clear answer.

How Agents Share Context

Each agent receives a slice of the context relevant to its role. For example:

• TokenAgent gets token metadata, deploy time, volume, supply

• WalletAgent gets the deployer address and wallet history

• LPAgent gets liquidity movement and contract permissions

They don’t step on each other’s data. This separation keeps each analysis focused.

After all responses are in, the Query Handler:

• Prioritizes the most urgent signals (e.g. LP unlocked, rug deployer)

• Removes redundancy (don’t repeat “LP not burned” 3 times)

• Formats the combined result clearly

Workflow Example

You ask:

“What’s the deal with $ZAP?”

Forge triggers:

• TokenAgent: “$ZAP launched 4 min ago, 12 SOL LP, no burn, ownership not renounced.”

• WalletAgent: “Deployer is 111abc, previously launched 2 tokens. One rugged, one low volume.”

• SniperAgent: “Wallet 555abc entered with 20 SOL. Known sniper, sold last 5 tokens within 5 mins.”

Final reply:

“$ZAP launched 4 mins ago with 12 SOL LP (unburned, ownership not renounced). Deployer has a mixed history including 1 rug. Known sniper 555abc just entered with 20 SOL. High risk.”

You get one answer, but three agents did the work.

Chaining Custom Agents

You can create your own workflows using custom agents. For example:

1. An “InfluencerAgent” watches Telegram or Twitter

2. When a deployer is flagged, it triggers a “ContractScanAgent”

3. If red flags appear, it sends an alert through a “NotifierAgent”

Each stage in the chain activates the next, building a full lifecycle of detection, verification, and alert.

This is useful for:

• Private trading groups

• DAO security desks

• Automated due diligence pipelines

Benefits

• Speed – Parallel agents reduce wait time

• Depth – Each agent is specialized and focused

• Clarity – Results are organized, not dumped

• Scalability – Add more agents as your needs grow

Forge becomes more intelligent not by having one massive model, but by letting many smaller processes cooperate efficiently.

Not all tokens behave the same. Some are slow burns. Some spike and rug. Some are bought by insiders only. Forge can identify these patterns by analyzing a token’s lifecycle from creation to sell-off.

This page covers how Forge tracks token behavior over time and how agents detect trends, risk factors, and unusual movements.

What Is Token Behavior?

Token behavior refers to the patterns that emerge after launch:

• How fast volume builds

• Who’s buying and when

• If LP is manipulated

• When and how early wallets sell

• Whether social metadata is used to bait entries

• If it’s being farmed by repeat wallets

Forge tracks this behavior in real-time and uses it to help agents answer questions like:

• “Is this token being botted?”

• “Does this look like an organic launch?”

• “Any signs of insider trading?”

What Forge Looks For

Each token is continuously scored across several dimensions:

Launch Quality

• Was LP added in a normal time window?

• Was ownership renounced?

• Did the deployer join Telegram groups before launch?

Buy Pattern

• Are entries spread out or clumped into a few wallets?

• Any early buys from known sniper clusters?

• Was the LP front-run?

Volume Curve

• Did the volume ramp up smoothly?

• Was there a sharp spike then instant dump?

• Are new buyers sustaining the chart?

LP Behavior

• Is liquidity burned or locked?

• Any sudden removal of LP?

• Any unusual LP minting or transfers?

Wallet Exit Timing

• How fast are wallets selling?

• Are most sells below profit?

• Did the deployer sell into volume?

These metrics are all recorded per token and used to inform Forge’s responses.

Behavior Tags

Forge automatically labels tokens with behavior tags like:

• Organic Launch

• Sniper Farmed

• High Risk: Fast Exit

• Volume Spike + Dump

• Stealth Launch

• Bot-Heavy Distribution

• No Socials

These tags appear in chat replies and are also available when viewing a token’s full breakdown.

How It Helps

Let’s say you ask:

“Is $MEOW safe?”

Forge might respond:

“$MEOW launched 6 mins ago with 18 SOL LP. LP not burned. Wallet 7AuCty... bought 15% of supply at launch and sold 3 mins later. High concentration of buys from sniper cluster wallets. No socials. High risk pattern: sniper farmed + no burn.”

This combines:

• Token metadata

• Buyer wallet behavior

• LP conditions

• Volume slope

• Sell timing

All into one reply you can act on instantly.

Custom Behavior Filters

If you’re self-hosting or building a private tool, you can set your own thresholds for what counts as suspicious.

For example:

• Label “sniper farmed” if more than 40% of buys come in within 10 seconds

• Tag “slow burn” if volume grows steadily for 30+ minutes without sharp exits

• Create custom alerts for tokens where deployer joins Telegram 1 hour before launch

These filters can also trigger automated workflows like alerts or deeper agent chains.

Forge is strongest when it sees everything. While its native indexer captures live on-chain events, sometimes you need context from outside the blockchain — like Telegram data, Twitter signals, trending words, or even centralized price feeds. That’s where API integration comes in.

This page explains how to plug external data sources into Forge so your agents can react to signals beyond Solana.

Why Integrate External APIs

On-chain activity only tells half the story. Many key events start off-chain:

• A Telegram KOL posts alpha

• A deployer joins a chat group

• A wallet gets funded after a Discord mention

• A Twitter thread goes viral and sparks a memecoin pump

By integrating APIs, you allow Forge to:

• Trigger agents based on social activity

• Combine off-chain signals with on-chain responses

• Build richer prompts with external data

• Monitor coordinated behavior across platforms

This turns Forge into a multi-channel intelligence system.

Common Integration Examples

Here are a few ways APIs are already used inside Forge:

Telegram

• Track when known wallets join groups

• Monitor messages in target chats for keywords

• Flag new deployers who joined high-risk groups

Twitter

• Scan tweets from influencers

• Track hashtags tied to new coins

• Monitor followers of known dev wallets

CoinGecko / Price APIs

• Pull current SOL price

• Compare market cap to USD

• Use real-world benchmarks in risk scoring

TradingView or Custom Signal Feed

• Check if a coin has crossed RSI thresholds

• Pull volume metrics for major listings

Handling Rate Limits and Failures

Make sure your API code:

• Handles timeouts and bad responses

• Uses caching if data doesn’t change frequently

• Respects rate limits from the source

You don’t want your agents to crash just because a server is slow.

Secure API Keys

If using services that require API keys:

• Store keys in .env

• Never log them or inject them into prompts

• Use proxy services if needed to obscure source

Example:

iniCopyEditTWITTER_API_KEY=xxxxx

Inside your code:

tsCopyEditconst headers = {
  Authorization: `Bearer ${process.env.TWITTER_API_KEY}`
}

Best Practices

• Keep off-chain data short and relevant in the prompt

• Timestamp everything, especially when correlating with blockchain events

• Sanitize and label external content clearly

• Don’t overload your prompt with unnecessary noise

Remember, the goal is to make the AI smarter, not just feed it more data.

One of Forge’s most important functions is identifying wallets that consistently behave in ways that suggest manipulation, sniping, or malicious intent. Whether it’s a deployer launching rugs, a sniper farming liquidity, or a wallet that front-runs every new coin, Forge is built to detect and surface these actors in real time.

This page explains how suspicious wallet detection works and how you can use it to stay ahead of risky behavior.

What Counts as Suspicious?

Forge doesn’t rely on gut feeling. It uses specific patterns and repeat behaviors to score wallets based on risk. Some examples include:

Sniper Wallets

• Buys within 1–5 seconds of token creation

• Always enters with large amounts (10+ SOL)

• Sells within 3–5 minutes after launch

• Often avoids LP-rugged tokens

Deployer Wallets

• Launches 3+ tokens within 24 hours

• No ownership renounce

• LP unlocked in all launches

• History of 0 volume or fast rugs

Exit Farmers

• Buys a large share of supply

• Sells to every wave of volume

• Buys and exits repeatedly across many tokens

• Connected to wallet clusters using same behavior

Telegram-Linked Front-Runners

• Joins Telegram groups before a token launch

• Buys immediately after a post

• Often linked to dev or KOL circles

What Forge Tracks

Forge agents continuously track wallet-level activity, including:

• Token buy and sell logs

• Time between wallet funding and first buy

• Tokens deployed or interacted with

• Telegram group joins (if linked)

• Past wallet flags and risk scores

• Frequency of activity within short windows

These are not just event logs. They’re combined into behavior profiles with scoring logic.

Example Detection

You ask:

“What’s this wallet 7AuCty3w... been doing?”

Forge replies:

“Wallet 7AuCty3w... entered 11 tokens in the past 6 hours. All buys were within 10 seconds of LP creation. In 9 of those cases, it sold within 3 minutes. Has funded 3 new wallets using same pattern. Risk score: 9/10. Likely sniper farm operation.”

This shows:

• Consistency of behavior

• Speed of entry and exit

• Wallet links and clustering

• Scoring based on agent-defined thresholds

Wallet Scoring

Forge assigns internal scores to wallets between 1 and 10. You can see this in responses or full profiles:

• 1–3: Normal behavior

• 4–6: Possibly bot-controlled or opportunistic

• 7–8: Repeated risky behavior or manipulation

• 9–10: Confirmed sniper, rug deployer, or multi-wallet farm

You can also build custom agents to auto-flag any wallet over a certain threshold and take action (like sending a memo, alerting a team, or blacklisting it).

Wallet Clustering

Forge detects wallet clusters using:

• Shared funding sources

• Similar timing of trades

• Deploying the same token sets

• Repeated buys into the same tokens within seconds

This helps you spot sniper farms or coordinated buyer groups who rotate wallets to stay hidden.

Private Watchlists

You can manually tag wallets:

• “Likely sniper”

• “Known deployer”

• “Blacklist”

• “Verified community buyer”

These tags persist in your own Forge instance and influence how agents score them in future interactions. You can also share tags across your team or API clients.

One of the fastest ways to spot a rug or a high-risk token is by analyzing its liquidity pool (LP). Forge includes a dedicated LP Scanner module that tracks the creation, behavior, and structure of LPs across new tokens on Solana. It works in real-time and feeds data directly into Forge’s agents and query responses.

This page explains how the LP Scanner works, what it detects, and how it can help you avoid traps and find legitimate setups.

What the LP Scanner Does

The LP Scanner monitors new tokens for:

• When and how LP is added

• What ratio of token to SOL was seeded

• Whether LP is burned, locked, or still owned

• Changes in LP over time (additions, removals)

• Unusual patterns that often lead to rugs

It operates as part of Forge’s indexer, watching every transaction and routing updates into the token context.

What It Looks For

Here are some of the key LP signals the scanner detects:

LP Creation Event

• Timestamp of first LP creation

• Source of liquidity (deployer vs. fresh wallet)

• Pair type (e.g. SOL/token)

LP Ratio

• How much SOL vs. how much token was added

• Detects underseeded or overinflated liquidity

• Flags setups where deployer keeps a large supply while LP looks balanced

LP Burn or Lock

• Whether the LP was sent to a burn address

• Locked via external service or renounced router

• If still owned by a wallet, it’s marked as “LP Unlocked”

LP Transfers

• LP moved after creation

• Removed liquidity events

• Transfer to stealth wallets or mixers

LP Removal Timing

• How long LP stayed in place before being pulled

• If LP is removed early, triggers an instant rug tag

How It Helps You

You ask:

“Is $BAG safe?”

Forge includes LP Scanner data in the response:

“$BAG launched 7 minutes ago with 12.3 SOL LP. LP not burned, still held by 7AuCty3w... Volume spiked to $26k, and deployer has 2 prior rugs. LP is at risk.”

This gives you real, on-chain info you can act on immediately.

Real-Time Alerts

If you’re using the hosted version or have notifications enabled, the LP Scanner can:

• Trigger alerts when LP is added without burn or lock

• Auto-flag tokens with LP removed in the first few minutes

• Push notifications to Discord, Telegram, or browser

These alerts are fast — usually less than 2 seconds after the on-chain event.

Advanced Features

For self-hosted or advanced users:

• Set your own LP thresholds (e.g. min 10 SOL LP, min 90% burn)

• Customize risk rules (e.g. flag if LP is added from funded wallet)

• Combine LP Scanner output with WalletAgent for deeper analysis

You can also write your own scripts to scan every new token against LP rules and automatically tag good setups for entry.

Example Use Cases

• Avoiding Rugs: LP not burned and held by deployer? Walk away.

• Finding Real Launches: LP burned, good ratio, renounced ownership? Worth watching.

• Sniper Farming Detection: LP added with bait ratio, but no burn and instant sniper buys? High risk.

• Entry Opportunity: LP added clean, volume still low, solid holder spread? Early window.

Rug prevention starts with one key check — was the LP burned? The LP Burner Tracker module in Forge watches every new token on Solana and logs whether the liquidity pool was permanently burned, locked, or left exposed.

This module works in tandem with the LP Scanner and feeds directly into token risk assessments, giving you real-time feedback on the most critical part of launch safety.

What the LP Burner Tracker Does

This module monitors:

• LP burn transactions

• Tokens sent to dead addresses (e.g. 11111111111111111111111111111111)

• LP tokens sent to lockers or burned by contract

• Timing of the burn (immediate vs. delayed)

• LP burn reversals or redeploys

It flags LPs as:

• Burned – permanently destroyed, no owner

• Locked – time-locked in a 3rd-party contract

• Unlocked – still accessible by deployer or wallet

How It Detects LP Burns

The tracker looks at:

• Token balances of LP tokens after creation

• Transfers to known burn addresses

• Interactions with locking protocols like PinkLock or Uniloc

• Manual burns from deployer wallets

It matches these to a growing database of known burn addresses and locker contracts to verify burn legitimacy.

In-Chat Response Integration

Ask a question like:

“Is LP burned on $SPIN?”

Forge returns:

“$SPIN LP is unburned and still controlled by deployer wallet 7AuCty3w... No lock detected. LP can be removed at any time.”

If burned:

“$SPIN LP was burned 2 minutes after launch. Verified send to 111111111... No lock detected. LP is now permanent.”

Forge will also note delayed burns, which sometimes suggest bait setups. For example:

“LP was burned 6 minutes after launch, after a volume spike of $30k. High risk of post-entry rug bait.”

Risk Signal Integration

The LP Burner Tracker directly feeds into token safety scores:

• Burned LP increases trust score

• Unburned LP held by deployer flags high risk

• Early volume before burn may reduce safety even if LP is later burned

Agents use these signals to adjust how they label and explain a token.

Burn Timing Breakdown

Burning LP isn’t just about if — it’s about when.

The tracker logs timing stats like:

• Time between LP creation and burn

• Volume at moment of burn

• Number of unique buyers before burn

These are used to flag delayed bait tactics — where LP is left open just long enough to bait in early traders, then burned to fake legitimacy.

LP Lock Detection

The module also detects if LP is locked, not burned:

• Uses a registry of locker contracts

• Detects lock durations

• Flags if LP can be reclaimed or unlocked prematurely

Locked LP is safer than unlocked, but still not as final as a burn.

When big wallets move, markets follow. The Whale Movement Watcher module in Forge tracks high-value wallets across Solana, monitors their activity in real time, and surfaces alerts when they enter or exit tokens, fund new wallets, or behave in ways that suggest insider knowledge or early entry.

This module is designed for traders who want to trace smart money and front-runters before momentum hits the chart.

What It Tracks

The Whale Movement Watcher focuses on:

• Wallets holding large SOL or token balances

• Wallets consistently early to high-volume tokens

• Clusters of wallets that buy together

• Funding paths between whales and deployer wallets

• Repeat large entries into new tokens

It logs every significant move made by tracked whales and highlights abnormal behavior.

Whale Criteria

Forge defines whales based on customizable thresholds:

• Wallets holding > 500 SOL

• Wallets entering with > 20 SOL into a single token

• Wallets profiting on 3+ launches per day

• Wallets that fund multiple sniper wallets

You can override or expand this list in your Forge settings, including tagging your own whale watchlist.

Example Use Case

You ask:

“Any whales just entered $TOAST?”

Forge returns:

“Wallet Fz9pAb... entered $TOAST with 26 SOL, 30 seconds after LP creation. This wallet has profited on 6 of its last 7 entries. Known for early high-volume buys. Likely smart money entry.”

You now have a signal worth watching — a large wallet moved early with size and has a good track record.

Funding Path Detection

Many whales don’t buy directly. Instead, they:

• Fund smaller wallets

• Use burner wallets for stealth

• Rotate between wallets to avoid tracking

The Whale Movement Watcher detects these behaviors by mapping:

• Recent SOL transfers

• Wallet reuse patterns

• Timing correlations between funding and buys

This allows you to trace back stealth wallets to their origin and group them under one whale profile.

Alerts and Triggers

Forge can notify you when whales:

• Enter or exit a tracked token

• Fund a fresh wallet that buys something immediately

• Sell their entire position in one move

• Interact with tokens from known Telegram deployers

You can get alerts via chat, push, Discord, or in a summary feed.

Whale Profiles

Each tracked whale gets its own profile, showing:

• Lifetime PnL across tracked launches

• Entry and exit timing stats

• Most frequent collaborators (wallet links)

• Tokens entered in the last 24 hours

• Risk or manipulation tags (e.g. fake-outs, early sells)

This lets you decide if they’re worth following — or avoiding.

Strategic Use

Use this module to:

• Front-run meme tokens whales are farming

• Avoid tokens that whales just dumped

• Watch which whales enter launches from a specific Telegram group

• Monitor if a known sniper farm is rotating into new positions

Whale movement is often one of the clearest signals — Forge just turns it into something you can actually use.

Forge is powerful because it injects the right data into the right model — but the final output depends entirely on how the prompt is written. Prompt engineering is where you define how an agent thinks, what it focuses on, and how it speaks.

This page explains how to write and customize prompt templates inside Forge, so your agents generate better responses, tailored to your goals.

What Is a Prompt Template?

A prompt template is a structured block of text sent to the language model. It includes:

• Real-time on-chain context (e.g. LP size, wallet behavior)

• A system instruction (what to do with the data)

• A formatting preference (style, tone, output type)

Agents use these templates to speak in different voices depending on who’s asking — traders, analysts, devs, researchers.

Prompt Structure

Every prompt in Forge follows a consistent structure:

yamlCopyEditToken Context:
- Name: $DUCK
- LP: 18 SOL, unlocked
- Ownership: Not renounced
- Deployer: 7AuCty3w..., 3 rugs in last 24h

Wallet Context:
- Known sniper 8fjNqk... bought 5% supply
- 2 large sells within first 3 minutes

Instruction:
Summarize risk profile in plain language. Include deployer risk, LP safety, and buyer pattern. Respond as if explaining to a cautious trader.

This allows the language model to reason based on clear, factual context with a specific communication style.

Customizing a Prompt

Inside your agent’s logic, you can rewrite the prompt template:

tsCopyEditprompt: (ctx) => `
Token ${ctx.name} launched ${ctx.minutesAgo} ago with ${ctx.lp} SOL liquidity.
Deployer wallet ${ctx.deployer} has launched ${ctx.previousLaunches.length} tokens before, ${ctx.rugCount} of which rugged.

Buyers include ${ctx.sniperCount} sniper wallets.

Give a clear risk assessment and explain red flags to a human reader.
`

You can include:

• Context formatting (bullet points, JSON, paragraphs)

• Output type (summary, full breakdown, warning alert)

• Tone (formal, casual, trader-style)

Tips for Better Prompts

• Be specific — define exactly what the model should analyze

• Avoid ambiguity — structure data into clean sections

• Limit scope — include only relevant facts, avoid overload

• Use natural instructions — talk to the model like a smart intern

Examples:

✅ “Summarize this token’s safety based on deployer risk, LP status, and wallet buys.” ❌ “Tell me everything about this.”

Multi-Agent Prompt Chains

Each agent in Forge can run its own prompt, but sometimes one agent’s output becomes another agent’s input.

For example:

1. TokenAgent scans LP + metadata

2. WalletAgent adds deployer history

3. QueryHandler merges both into one composed prompt

You can engineer this merge behavior and even apply a final instruction like:

“Merge all findings into a single reply for a degen trader on mobile.”

Prompt Debugging

To troubleshoot or refine prompt output:

• Log the full prompt in dev mode

• Test same prompt in OpenAI Playground or Claude

• Adjust tone, remove redundant data, or refine instructions

• Compare output between different model backends

Small tweaks in phrasing can drastically improve results.

Forge was built with the principle that powerful analytics shouldn’t compromise safety. Whether you’re using the hosted version or running a self-hosted deployment, Forge is designed to respect user privacy, protect data, and avoid exploitative behavior.

This page explains how Forge handles on-chain data, user interactions, and external integrations while maintaining a secure and transparent environment.

🔐 What Forge Does Not Do

• Forge does not front-run trades

• Forge does not auto-execute transactions

• Forge does not store private keys or wallet seed phrases

• Forge does not monitor or retain personal DMs or Telegram content

• Forge does not use AI to generate fake token activity or bots

Everything Forge analyzes is based on publicly available, on-chain activity and open-access social metadata (when provided by token deployers or visible in groups).

📡 On-Chain Data Access

Forge only listens to:

• Token launches

• Wallet transfers

• Liquidity pool actions

• Contract metadata

• Public Telegram wallet joins (where possible)

All data is processed in-memory or cached securely. No sensitive information is harvested, injected, or stored outside what’s already public on Solana.

🧠 Language Model Handling

If you're using the hosted version:

• Prompts are processed through OpenAI (GPT) or Anthropic (Claude) via encrypted API

• No wallet data or secrets are sent

• Context is sanitized before model input

• Forge does not allow external models to store chat history or track identities

In self-hosted setups:

• You choose your own model endpoint

• You retain full control of prompt formatting, token usage, and inference logs

🗂 User Session Data

In the hosted UI, Forge temporarily stores:

• Session chat history

• Agent response logs

• Follow-up action context

This is session-scoped and can be cleared or disabled entirely.

For teams or DAOs, shared instances can be configured with role-based access and separate workspaces.

🔄 API Security

When using external APIs (Telegram, Twitter, etc.):

• All keys are stored in environment variables (.env)

• No keys are injected into AI prompts

• API usage is rate-limited and scoped to read-only endpoints

• If keys are compromised, Forge fails safe and disables related modules

You should never expose Telegram bot tokens or trading keys directly in any agent logic.

🛡 Safe Usage Guidelines

To keep your Forge instance secure:

1. Never use or connect private keys to Forge

2. Host behind HTTPS with rate limiting if public

3. Use .env secrets and never hardcode sensitive data

4. Regularly update from upstream if you forked

5. Monitor logs for excessive API hits or unexpected prompts

If you're building your own commercial version, consider adding login, wallet auth, or workspace isolation layers.

Many of the most aggressive buys on new tokens aren’t random — they’re triggered by Telegram. Deployers leak info to private chats, snipers monitor KOL groups, and wallets flood in the second a new project is mentioned. The Telegram Sniper Detector module in Forge was built to catch this exact behavior.

It links wallet activity to group joins, traces deployer movements across Telegram communities, and helps you understand if a meme is being farmed by insiders.

What It Does

This module monitors:

• Known Telegram groups where snipers and KOLs gather

• Wallets linked to those groups

• Deployers who join groups before launching tokens

• Timing between group joins and token buys

• Repeat wallet appearances across multiple launches

It detects Telegram-connected behavior, which often signals insider coordination, KOL baiting, or stealth sniper farms.

Wallet Linking

Wallets are linked to Telegram using:

• Wallet signatures inside group chats (via DegenBox bots, snipe groups, sniper bot wallets)

• Links between deployers and known group metadata

• Funding patterns tied to sniper bot clusters

Once a wallet is identified in a group, Forge tracks when it:

• Joins a chat

• Sends messages (if available)

• Buys tokens shortly after

• Deploys a token with metadata posted in the group

How It Helps

Ask a question like:

“Any Telegram links for this token?”

Forge might respond:

“Token $WARP was deployed by wallet 7AuCty3w..., which joined ‘SolanaAlphaHub’ 1 hour before launch. First 3 buyers also present in same group. Pattern matches previous sniper farm setups.”

You can also run standalone queries like:

• “What tokens were launched by Telegram-linked wallets today?”

• “Which Telegram group is most active in fresh launches?”

• “Has this wallet joined any snipe groups?”

Detection Use Cases

This module is especially useful for:

• Sniper Identification – flagging wallets that follow every KOL call

• Insider Bait Detection – catching tokens pushed in chats before they rug

• Deployer Monitoring – seeing if a dev is part of known rug circles

• Front-Run Tracing – identifying wallets that buy tokens seconds after group joins

Telegram Join Timing

Forge analyzes the timing between a wallet joining a group and:

• A token deployment

• First token buys

• Sniper wallet movements

If these events happen within 1–10 minutes, it’s flagged as high correlation.

Example output:

“Wallet 9xTzK5... joined 'AlphaSnipers' 3 minutes before buying $DOGEZILLA. Bought 2 seconds after launch. Known repeat pattern across 8 tokens.”

Group Metadata

Each Telegram group tracked by Forge includes:

• Group name and alias

• Description (KOL, sniper hub, launchpad group, etc.)

• Linked wallet activity

• Risk rating (based on rug frequency from members)

This lets you track which groups are the most predictive — or the most dangerous.

Custom Group Tracking

If you run a private Forge instance, you can add:

• Your own list of Telegram groups

• Custom rules for detection

• Blacklist or whitelist filters

• Alerts for wallets joining tracked chats

You can even run daily reports on what groups were most active in launching or sniping tokens.

Every token starts with a creator — and that creator often tells you everything you need to know about what comes next. The Contract Creator Profiler module in Forge tracks every new token deployer on Solana and builds a behavioral history for them, so you can instantly see if a wallet is trustworthy, repeat-rugging, or playing smart.

This module powers deployer reputation scoring and is one of the most important signals used across all of Forge’s agents.

What It Does

The Contract Creator Profiler monitors:

• Wallets that deploy new SPL tokens

• Previous token launches from the same wallet

• Deployment frequency and time gaps

• LP setup and rug rate across deployments

• Use of social metadata, ownership renounce, LP burn

• Cross-token buy/sell behavior from the deployer wallet

It creates a live profile for every creator wallet Forge sees.

Key Data Points

Each deployer is tracked with the following fields:

• Total Tokens Deployed

• Time Since Last Deploy

• Rug Count – tokens where LP was removed or price dropped >95%

• Success Rate – tokens that hit a volume or market cap milestone

• LP Behavior – burned, unlocked, locked status across launches

• Metadata Usage – how often they inject socials, fake audits, etc.

• Deployment Timing – clustered or spaced out

You can ask Forge:

“Who deployed $GRIT?” “What else has this wallet launched?” “How often does this dev rug?”

Reputation Scoring

Forge assigns each contract creator a Reputation Score from 1 to 10:

• 1–3: High-risk, repeat rug deployer

• 4–6: Mixed history, likely opportunistic

• 7–8: Solid pattern, careful LP and lock behavior

• 9–10: Consistently safe launches, strong volume, burned LP

This score appears in responses and helps shape agent output.

Example Response

You ask:

“Is the $GRIT deployer safe?”

Forge responds:

“Wallet 7AuCty3w... deployed $GRIT 2 mins ago. This is their 5th token in 3 days. LP unlocked in all previous launches. 3 of those tokens dropped over 90% within 10 minutes. Reputation score: 2/10. High risk pattern: serial rug behavior.”

Token History View

You can view a deployer’s full launch history in timeline format:

bashCopyEditDeployer: 7AuCty3w...

- $BARK (Apr 22) – 10 SOL LP, unlocked, rugged
- $PLUMP (Apr 23) – 18 SOL LP, burned, died at 8k vol
- $ZYNX (Apr 23) – 5 SOL LP, rugged after 3 min
- $SPIN (Apr 24) – 20 SOL LP, locked, hit 40k vol

Forge auto-tags each with outcome (rug, low vol, success).

Cloning & Pattern Matching

The profiler can also detect wallets that copy known deployer behavior, such as:

• Same deploy + renounce + LP sequence

• Matching liquidity ratios

• Same contract bytecode or token metadata structure

This helps catch copycats or burner wallets trying to hide identity.

Alerts & Automation

For advanced users:

• Set alerts when a known rug deployer launches again

• Flag deployers over X launches within Y hours

• Trigger auto-replies like: “Warning: Deployer has rugged before”

• Feed deployer history into sniper filters

Useful for launchpad teams, Telegram groups, and sniper farms avoiding known traps.

Forge uses technical terms from both blockchain analytics and AI infrastructure. This glossary provides clear definitions for common terms used throughout the Forge documentation and system.

Use this page to quickly understand what each term means when it appears in responses, settings, or module names.

A

Agent A modular logic unit in Forge that analyzes a specific type of query or event, such as TokenAgent, WalletAgent, or LPAgent.

AI Query Handling The process of transforming a user question into a structured prompt, sending it to a language model, and formatting the output.

API Application Programming Interface — used in Forge for external data integrations like Telegram or Twitter feeds.

B

Burn (LP Burn) The act of permanently destroying liquidity tokens so the LP can’t be pulled. A key safety signal for memecoins.

C

Contract Creator The wallet that deployed the SPL token. Often used to evaluate trustworthiness or detect rug patterns.

Context Injection The process of inserting real-time, on-chain data into a language model prompt.

Custom Agent An agent written by the user or developer, tailored to specific behavior, events, or data pipelines.

D

Deployer The wallet that launches a token contract. Same as “contract creator.”

Degen A casual term for high-risk crypto traders, typically active in meme markets.

E

Event Hook A trigger that activates an agent, such as “New Token Created” or “LP Burn Detected.”

F

Forge The core platform that powers on-chain AI chat and data intelligence on Solana.

Forking Creating a personal or team-specific version of Forge with custom branding, agents, and prompts.

G

Group Join (Telegram) The action of a wallet-linked identity joining a Telegram group, often used in sniper detection.

I

Indexer The backend service that watches the Solana blockchain and records key events for fast access.

L

LP (Liquidity Pool) A pair of assets (usually token and SOL) used to allow decentralized trading. Often targeted in rug pulls.

LP Scanner The Forge module that monitors LP creation, burn, and manipulation in real time.

LP Burner Tracker Module that confirms if LP tokens were sent to a burn address or locked away.

M

MCP (Model Context Protocol) Forge’s system for building structured prompts using real-time context. Ensures accurate responses.

Model The large language model used to generate Forge responses (e.g. GPT-4, Claude).

P

Prompt Template A structured set of instructions and data sent to a language model.

Prompt Engineering The practice of designing and optimizing prompt templates for clarity and performance.

R

Rug A scam token where the deployer removes LP or sells into volume, causing a total price collapse.

Reputation Score Forge’s trust score for wallets or deployers, based on history, rug count, LP behavior, and volume trends.

S

Sniper Wallet A wallet that buys very early after token launch, often farming multiple tokens for quick exits.

Suspicious Wallet A wallet with consistent rug behavior, sniper timing, or insider funding patterns.

T

TokenAgent An agent that scans token metadata, contract settings, LP, and deployer history.

Telegram Sniper Detector A module that links wallet activity to Telegram group memberships.

W

WalletAgent An agent that profiles wallet behavior, funding patterns, and sell activity.

Whale Movement Watcher Forge module that tracks high-SOL wallets and their token entries and exits.

Forge was built for a specific kind of user — the trader, builder, or researcher who wants real insight from Solana without scrolling through endless charts, bots, and noise. But this is just the beginning.

This page outlines where Forge is heading next: new features, platform upgrades, and the long-term vision of what on-chain AI should become.

📅 Short-Term Roadmap (Next 1–2 Months)

1. Multi-Chain Expansion

• Add Ethereum (ERC-20) and Base token detection

• Index deployers and LPs across other chains

• Unified agent behavior across chains

2. Model Customization

• Support user-selected LLMs per agent

• Allow prompt tuning inside the interface

• Token-by-token personality settings (e.g. casual for memes, formal for LP bots)

3. Saved Workspaces

• Multi-chat tabs with session memory

• Save watchlists, wallet traces, and token threads

• Workspace export for research and reports

4. Interactive Agent Responses

• Clickable breakdowns (charts, tabs, “show more”)

• Wallet trace maps

• Token risk sliders

🧭 Mid-Term Vision (Next 3–6 Months)

1. Autonomous Agent Loops

• Agents that operate independently in the background

• Continuous monitoring of wallets or Telegram groups

• Trigger follow-up messages based on new events

2. Marketplace for Agents

• Create, publish, and sell custom agents

• Load public agents from a verified library

• Add your own brand/strategy logic on top of Forge’s core

3. Mobile & Telegram Bot Interface

• Native mobile chat with push alerts

• Telegram chatbot that connects to your Forge instance

• Compact answers designed for fast scanning

🧠 Long-Term Vision

Forge is not just a chat tool. The endgame is to build a modular AI infrastructure for on-chain intelligence that:

• Thinks like a trader

• Sees like a scanner

• Learns like a strategist

• And talks like a friend

We want to make every wallet, every token, and every movement readable and explainable in real time — whether you’re a beginner or a professional fund.

Eventually, Forge could become:

• An AI co-pilot for all of crypto

• A plug-and-play backend for meme projects

• A security layer that explains red flags before they hurt people

• A transparent record of what’s really happening on-chain, 24/7

🌍 Community and Collaboration

As Forge evolves, community contributions will drive:

• New agent ideas

• Shared prompt templates

• Language support

• Integration with launchpads, tools, and Telegram bots

If you’re a builder, you’ll be able to use Forge like a backend. If you’re a trader, you’ll be able to customize it to your edge. If you’re a team, you’ll be able to fork it and scale it to your ecosystem.

Forge is powerful, but it’s not perfect. Knowing what it can and can’t do will help you ask better questions, interpret answers properly, and avoid relying on it for things it was never meant to do.

This page outlines the current limitations of Forge, the boundaries of the data it uses, and what’s planned for future improvement.

What Forge Can Do

Forge is designed for:

• Analyzing fresh token launches

• Tracking wallets, deployers, and sniper activity

• Detecting LP changes and rug patterns

• Surfacing red flags fast

• Summarizing complex on-chain activity in seconds

It works best in the fast-moving world of Solana memecoins, where real-time decision-making matters.

What Forge Can’t Do

Forge is not a trading bot, a prediction engine, or a replacement for your own judgment.

It cannot:

• Predict price movements

• Tell you when to buy or sell

• Guarantee token safety

• Replace a full code audit

• Handle cross-chain analysis (yet)

Its role is to assist, not act.

Data Scope

Forge currently works only on the Solana blockchain. All of its agents, indexers, and logic are tailored to Solana’s architecture.

Tracked data includes:

• SPL token creation

• Contract renounce or burn

• Wallet funding and transaction flows

• LP creation, burn, and unlock

• Deployer reputation

• Telegram-linked behavior

• Sniper wallet activity

It does not currently track:

• NFTs

• Serum or CEX-based activity

• On-chain governance

• Slow long-tail DeFi projects

The focus is on high-velocity memecoin markets, not complex protocols.

Live Data Boundaries

Forge relies on its own indexer, so it’s extremely fast — but not instant to the block.

Typical delay: 0.5 to 2 seconds If you ask a question right as an event happens, you may need to wait a moment for the indexer to sync.

In rare cases, Forge may say “no data yet” if something literally just occurred.

Language Model Constraints

The quality of responses depends on the language model used. On hosted Forge, it defaults to GPT-4. In self-hosted versions, you can switch to any model you prefer, but cheaper or smaller models may give:

• Shorter answers

• Weaker reasoning

• Less consistent formatting

Forge gives you control — but performance varies with your setup.

Agent Limits

Some agents are still experimental or limited in what they can see. For example:

• TelegramAgent only detects groups Forge already indexes

• SniperAgent can miss stealth buys if wallets mask timing

• LPAgent may not detect nonstandard routers

These edge cases are constantly being improved, and users can suggest better heuristics or create their own agents to fill gaps.

Privacy and Ethics

Forge does not store private wallet data, front-run trades, or automate transactions.

All analysis is:

• Based on public blockchain activity

• Generated in response to user queries

• Non-invasive and transparent

If you’re running a private Forge instance, the same rules apply — it’s a tool for understanding, not exploiting.

Forge is powered by agents — intelligent components that specialize in analyzing tokens, wallets, LPs, and more. You don’t need to know how they work behind the scenes, but understanding how to interact with them will help you get the most out of Forge.

This page explains what happens when agents respond, how you can trace their logic, and what tools are available to go deeper after an answer is given.

What Happens When You Ask a Question

When you type a question in Forge:

1. The system figures out what kind of question it is (token, wallet, sniper, etc.)

2. It picks the right agent or group of agents to handle it

3. Those agents run their logic and send back a structured prompt

4. Forge returns an answer based on what the agents found

You’ll usually see a single, human-readable reply, but behind it, one or more agents were involved in generating it.

Agent Logs

To give you full transparency, Forge shows which agents were activated for your question. You’ll see a small tag or icon with the agent’s name like:

• TokenAgent

• WalletAgent

• SniperAgent

• LPAgent

You can click on these tags to expand the response and view the raw logic the agent followed. This might include:

• Event triggers (e.g. token launched 2 min ago)

• Data points pulled (e.g. deployer history, LP size)

• Risk scores or confidence levels

• Agent reasoning notes

This lets you see not just the conclusion, but how it was reached.

Follow-Up Actions

After an agent responds, you’ll often see optional follow-up buttons like:

• “Trace wallets involved”

• “Analyze deployer history”

• “Show LP chart”

• “View contract details”

These are shortcuts for triggering deeper agent tasks. Clicking one sends a refined query directly to the relevant agent, pre-filled with the right context.

This saves you from retyping or guessing what to ask next.

Multistep Workflows

Some interactions trigger multi-agent sequences. For example:

You ask:

“Is this token safe and who deployed it?”

Forge triggers:

• TokenAgent to check structure

• WalletAgent to review deployer history

• LPAgent to scan burn and lock status

Each returns a portion of the answer, and the chat interface combines them into one final response. You’ll see each agent’s tag at the bottom, and can expand each one if you want to view their logic separately.

Agent Memory

Most agents are stateless and respond only to real-time context. But some advanced agents retain short-term memory within a single session.

This means:

• You can follow up without repeating the token or wallet

• You can ask “what’s next?” or “show more” and get a deeper reply

• Agents remember your last focus (e.g. still analyzing the same token or wallet)

Once the session ends or you switch topics, the context resets.

Adding Custom Agents (Advanced)

If you’re self-hosting Forge or using a developer instance, you can:

• Create your own agent with a defined purpose

• Choose what triggers it listens for

• Set its context and prompt template

• Define how it responds

You can even combine agents into chains to support deeper workflows, like deployer fingerprinting, sniper flagging, or LP trend tracking.