SignalForge: Building a Competitive Intelligence Agent That Remembers

SignalForge: Building a Competitive Intelligence Agent That Remembers
Competitive intelligence usually starts with a simple question:
“What has changed with our competitors, and what does it mean?”

The difficult part isn't finding individual competitor updates. The difficult part is remembering those updates, connecting them across weeks or months, and recognizing when several small events form a larger strategic pattern.
That is the problem I built SignalForge to address.
SignalForge is a competitive intelligence agent for product and strategy teams. Instead of treating every competitor announcement as an isolated piece of information, it maintains historical memory and uses that history to reason about how a competitor's strategy is evolving.
The core idea is simple:
An AI agent becomes more useful when it can remember what happened before.
The Problem: Competitor Information Is Fragmented
Imagine a company monitoring a competitor called AcmeCRM.
Over several months, the team might observe:

• A new AI automation feature
• A pricing change
• A product expansion
• A response to another competitor
• New AI-focused messaging
• Changes in the company's positioning Individually, these events don't necessarily tell us much. But when they are considered together, they can reveal a longer-term strategic direction. A traditional dashboard might show these events as a chronological list: January → AI automation announcement February → Pricing change March → Product response April → New AI positioning

The information exists, but the connection between the events is left to the person reading the dashboard.
SignalForge is designed to make that historical connection part of the agent's reasoning process.
Meet SignalForge
SignalForge is a competitive intelligence agent designed around three main ideas:

1. Observe competitor activity.
2. Remember important events and context.
3. Reason over history to identify strategic patterns. The application provides a dashboard containing competitor activity, market signals, historical events, and an Ask Agent interface. A user can ask questions such as: What changed in AcmeCRM's strategy over the last few months?

Instead of answering only from the latest event, the agent can use historical information to construct a broader response.
Why Memory Matters
A normal LLM interaction is often stateless from the application's perspective.
You provide context:
User → Context → LLM → Response

For competitive intelligence, this isn't always enough.
The agent needs to work with information accumulated over time:
Events
↓
Memory
↓
Historical retrieval
↓
Connections between events
↓
Reasoning
↓
Strategic intelligence

This is where Hindsight becomes an important part of SignalForge.
Hindsight is a memory system designed for AI agents. Instead of treating memory as a simple collection of text snippets, it allows an application to retain information and retrieve relevant historical context later.
We used Hindsight as the persistent memory layer for SignalForge.
Useful resources:

• Hindsight GitHub
• Hindsight Documentation
• Vectorize — Agent Memory SignalForge Architecture The architecture can be thought of as several layers: ┌─────────────────────┐ │ User / Team │ └──────────┬──────────┘ │ ▼ ┌─────────────────────┐ │ SignalForge UI │ └──────────┬──────────┘ │ ┌──────────▼──────────┐ │ Agent / API Layer │ └───────┬───────┬─────┘ │ │ ┌──────────┘ └──────────┐ ▼ ▼ ┌─────────────────┐ ┌─────────────────┐ │ Hindsight │ │ LLM │ │ Memory Layer │ │ Reasoning │ └─────────────────┘ └─────────────────┘ │ ▼ Historical competitor information

The important distinction is:
The LLM provides reasoning, while Hindsight provides persistent memory.
The Memory Flow
When competitor information is added to SignalForge, the application can retain the information in Hindsight.
Later, when a user asks a question, the application can retrieve relevant historical information.
Conceptually, the flow looks like this:
User Question
↓
Retrieve relevant memories
↓
Organize historical events
↓
Connect related events
↓
Provide context to the reasoning layer
↓
Generate intelligence

This changes the behavior of the application.
Instead of asking:
“What do you know about this competitor?”

we can ask:
“How has this competitor changed over time?”

That second question requires memory.
A Small Example of the Hindsight Integration
The application communicates with Hindsight through its API.
A simplified version of the interaction looks like:
const response = await fetch(
${HINDSIGHT_URL}/v1/default/banks/${HINDSIGHT_BANK_ID}/memories,
{
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: Bearer ${HINDSIGHT_API_KEY}
},
body: JSON.stringify({
content: competitorEvent
})
}
);

The important part isn't the API call itself.
The important part is what happens after the information is stored.
The same memory can become useful later when the agent needs historical context.
For example:
January event
+
February event
+
March event
+
April event
↓
Historical pattern

This is the behavior we wanted the memory layer to enable.
Before Memory vs. After Memory
Without persistent memory, a competitive intelligence assistant tends to focus on the information immediately available to it.
The interaction looks more like:
Question
↓
Current information
↓
Answer

With persistent memory:
Question
↓
Current information + historical memories
↓
Related events
↓
Timeline
↓
Pattern
↓
Answer

That difference is particularly important for strategy questions.
A single announcement may be insignificant.
Five related announcements over four months may represent a meaningful change in direction.
Asking SignalForge About Change
One of the main interactions in the application is the Ask Agent feature.
For example:
What changed in AcmeCRM's strategy over the last few months,
and how are the different events connected?

During testing, SignalForge returned multiple historical changes rather than simply describing the company.
We then asked:
Which of AcmeCRM's changes appears to be part of a
longer-term strategic pattern rather than an isolated event?

This is the kind of question that motivated the project.
The objective isn't just to retrieve information.
It is to make historical information useful for reasoning.
What We Learned While Building It
One of the biggest lessons was that adding memory is not the same as simply adding more context.
If an agent receives a large amount of unrelated information, having more data doesn't automatically make the answer better.
The memory needs to support questions such as:

• What happened?
• When did it happen?
• Which competitor was involved?
• What happened before it?
• What happened afterward?
• Are multiple events related?
• Is a recent event consistent with an earlier pattern? This is why the project focuses on historical relationships, not just storing competitor descriptions. The UI SignalForge provides a dashboard-oriented interface for exploring competitive intelligence. The prototype includes:
• Competitor monitoring
• Historical remembered events
• Market signals
• Competitor priority information
• Ask Agent
• Memory-oriented views
• Sales-call preparation
• Intelligence generation The goal is to keep the experience focused on a product or strategy user's workflow rather than exposing the underlying memory infrastructure directly. The user should be able to ask a strategic question and receive an answer grounded in the competitor's history. A Limitation We Encountered One important limitation during development was that the initial prototype operated with synthetic demo data and a demo fallback. That was useful for building and testing the interface, but it wasn't enough to demonstrate the core idea properly. The important step was connecting the application to an actual Hindsight memory bank and verifying that the agent could work with historical information. This changed the prototype from: Synthetic data → Demo response

toward:
Persistent memory → Retrieval → Agent reasoning

That distinction matters because the central idea of SignalForge depends on the agent being able to remember information beyond a single interaction.
What I Would Improve Next
There are several directions I would explore next.

1. More real-world sources The current prototype can be extended to ingest information from:
2. Competitor websites
3. Product announcements
4. Pricing pages
5. News
6. Research documents
7. Analyst observations
8. Internal notes

9. Better relationship detection
   The agent could become better at identifying relationships such as:
   Feature launch
   ↓
   Competitor response
   ↓
   Pricing change
   ↓
   New positioning

10. More explicit memory exploration
    A dedicated memory explorer could allow users to inspect:
    Competitor
    ↓
    Timeline
    ↓
    Events
    ↓
    Relationships
    ↓
    Learned patterns

11. Decision-oriented intelligence
    Ultimately, the goal is not to create another monitoring dashboard.
    The useful output is something closer to:
    “Here is what changed, why the sequence matters, and what your team should investigate next.”

The final decision should remain with the product or strategy team.
The Main Idea
The most important lesson from building SignalForge is that memory changes what an agent can do.
A normal assistant can answer questions about information it currently has.
A memory-enabled agent can build on what it has encountered previously.
For competitive intelligence, that difference is significant.
Competitor activity is inherently historical.
Strategies evolve through sequences of decisions, launches, reactions, pricing changes, positioning changes, and market movements.
If an agent only sees each event independently, it can miss the larger picture.
If it remembers the events and can retrieve them when needed, it can start reasoning about change over time.
That is what SignalForge is designed to explore.
Try SignalForge
The project is available on GitHub:
SignalForge on GitHub
SignalForge combines:

• React + Vite for the interface
• Backend/API logic for the agent workflow
• Hindsight for persistent agent memory
• LLM-based reasoning for generating intelligence The central architecture can be summarized in one line: Hindsight remembers → the agent connects → the LLM reasons → SignalForge explains

And that's the idea behind building an agent that doesn't just monitor competitors — it remembers how they evolve.