# Interacting with Agents

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.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.forgeonchain.ai/interacting-with-agents.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.