# Pulse: How Hindsight Memory Turns an Incident Dashboard into a Learning Machine

krishnakasaudhan0 — Sat, 11 Apr 2026 17:16:27 +0000

A deep dive into the AI-powered incident response agent built for the Hindsight Agent Memory Hackathon

The Problem with Forgetful Agents

Imagine calling a doctor who, every single visit, has no idea who you are. You re-explain your symptoms. You re-describe your history. They have no record that you mentioned chest tightness last Tuesday, no way to see that you've been tracking a recurring issue for two weeks.

Now apply that to your engineering team during an outage.

Every time a critical alert fires — database timeout, OOM-killed pod, API latency spike — engineers crack open a new incident and start from scratch. They dig through Slack threads, search runbooks, ping the one person who was oncall six months ago when "this exact thing happened." Institutional knowledge lives in human memory, Confluence pages nobody maintains, and post-mortem documents that get written and never read again.

This is the problem Pulse is built to solve. Not with a better dashboard. With memory.

What Pulse Is

Pulse is an AI-powered incident response agent. It acts like a highly experienced team member who has personally handled every outage your team has ever dealt with — and can instantly recall the root cause, the fix, and the lessons learned for any of them.

When a production system breaks and a new alert fires from tools like PagerDuty or Sentry, Pulse doesn't just display the notification. It immediately queries its memory bank, cross-references the incoming alert against every past incident, and surfaces a confidence-scored diagnosis:

"I've seen this before. Last time search service pods were OOM-killed, it was a memory leak in the query cache. Here's the exact playbook the team used to resolve it."

That's not a feature. That's the entire product philosophy: an incident agent that remembers.

The Architecture

Pulse is a React frontend backed by an Express webhook server, with Firebase handling authentication and multi-device sync. The stack is deliberately lean — JavaScript, Vite, and Firestore — because the complexity lives elsewhere: in the memory layer.

The data flow works like this:

An external monitoring tool (Sentry, PagerDuty, Datadog) fires a webhook when something breaks.
The Express server ingests it via Server-Sent Events and pushes the incident into the Pulse dashboard in real-time.
Pulse immediately runs a memory query against all past incidents, looking for semantic matches.
The matched incidents are used to generate a diagnosis — root cause, recommended fix, confidence score — delivered before the engineer has had time to scroll down.
When the incident is resolved, its full details (root cause, duration, timeline, lessons learned) are embedded into the permanent memory bank for future recall.

Every resolved incident makes the next diagnosis better. The system learns continuously without any manual curation.

The Role of Memory: From Noise to Signal

A single incident is noise. A pattern across dozens of incidents is a signal. The core insight in Pulse is that an agent without memory can only ever see noise.

Memory in Pulse isn't a log. It isn't a search index. It's a semantic understanding of what has happened before, structured in a way that makes it queryable against new, never-before-seen incidents. When a new alert comes in with slightly different wording, a different service slug, or a new error message — the memory system can still recognize that this looks like the database connection pool exhaustion from three months ago, and surface the fix.

This is what separates Pulse from a dashboard with a notes field.

Hindsight: The Memory Engine

The memory layer is built on Hindsight, a Vectorize semantic memory engine. Hindsight was chosen specifically because it doesn't just store raw text — it structures and embeds information in a way that supports semantic retrieval. Two incidents described in completely different language can still be recognized as similar.

The HindsightMemory class in Pulse exposes three core operations:

1. `retainIncident` — Write to Memory

When an incident is resolved, Pulse formats its full context — title, severity, affected services, duration, root cause, resolution, lessons learned, and timeline — into a structured memory document, then stores it in Hindsight Cloud:

async retainIncident(incident) {
  const content = this._formatIncidentForMemory(incident);
  // ...
  const res = await fetch(`/api/hindsight/v1/default/banks/${BANK_ID}/memories`, {
    method: 'POST',
    headers: this.headers,
    body: JSON.stringify({ items: [{ content }] })
  });
}

The formatted memory includes every structured field that might matter for future diagnosis. It's not a freeform note — it's a dense, semantically rich document that Hindsight can embed and retrieve precisely.

2. `recallSimilar` — Query for Matches

When a new incident arrives, Pulse constructs a natural language query from its title, description, affected services, and tags, then sends it to Hindsight's recall endpoint:

async recallSimilar(query) {
  const res = await fetch(
    `/api/hindsight/v1/default/banks/${BANK_ID}/memories/recall`,
    {
      method: 'POST',
      headers: this.headers,
      body: JSON.stringify({ query })
    }
  );
}

Hindsight returns ranked results with similarity scores. Pulse uses these to assemble a list of historically matching incidents — the raw material for diagnosis.

3. `reflect` — Generate the Diagnosis

Beyond simple retrieval, Pulse calls Hindsight's reflect endpoint to generate a synthesized analysis — not just "here are similar incidents" but "here is what I think is happening and what you should do":

async reflect(query) {
  const res = await fetch(
    `/api/hindsight/v1/default/banks/${BANK_ID}/reflect`,
    { method: 'POST', headers: this.headers, body: JSON.stringify({ query }) }
  );
}

Reflect combines retrieved memories with generative reasoning to produce an explanation grounded in actual past incidents. The output includes what similar incidents were, what their root causes were, what fixes worked, and which lessons apply to the current situation.

`diagnoseIncident` — The Full Pipeline

These three operations are combined in diagnoseIncident, which runs recall and reflect in parallel and merges the results into a single structured diagnosis object:

async diagnoseIncident(incident) {
  const query = `New production incident: "${incident.title}". 
    ${incident.description}. 
    Affected services: ${incident.affectedServices.join(', ')}. 
    Tags: ${incident.tags.join(', ')}. 
    What similar incidents have we seen? What was the root cause? What fix worked?`;

  const [recallResults, reflection] = await Promise.all([
    this.recallSimilar(query),
    this.reflect(query)
  ]);

  return {
    similarIncidents: recallResults.results || [],
    aiAnalysis: reflection.text || '',
    evidence: reflection.based_on?.memories || [],
    confidence: this._calculateConfidence(recallResults.results || []),
    source: this.cloudAvailable ? 'hindsight-cloud' : 'local'
  };
}

The confidence score scales with how many strong memory matches are found — a new system with three incidents in memory will express appropriate uncertainty, while a mature system with dozens of relevant precedents will give high-confidence recommendations.

The Hindsight Memory Lifecycle in Pulse

What makes Hindsight's role architecturally interesting is when memory is created. In Pulse, memories are not captured during an incident — they're captured after one is resolved.

This is intentional. During an active incident, the signal-to-noise ratio is terrible. Engineers are hypothesizing, reverting, trying things. The resolution state is the moment of highest clarity: the root cause has been identified, the fix has been confirmed, and the lessons have been written down.

Pulse hooks into the resolution lifecycle. When an incident's status changes to resolved, Pulse calls retainIncident, embedding the full structured record — including the manually written rootCause, resolution, and lessonsLearned fields — into Hindsight's permanent memory bank.

This is hindsight memory, in the literal sense: memory built from looking back at what actually happened, rather than trying to capture in-flight observations.

On the front end, the PulseContext initializes the memory engine on app load and immediately retains all previously resolved incidents in the background:

useEffect(() => {
  async function init() {
    await hindsightMemory.initialize();
    const resolved = state.incidents.filter(i => i.status === 'resolved');

    // Non-blocking — doesn't delay UI rendering
    hindsightMemory.retainAllIncidents(resolved).catch(console.error);

    dispatch({ type: 'SET_MEMORY_INITIALIZED', payload: true });
    dispatch({ type: 'SET_CLOUD_CONNECTED', payload: hindsightMemory.cloudAvailable });
  }
  init();
}, []);

The memory score displayed in the dashboard is a direct function of how many resolved incidents are in memory. More resolved incidents means more accurate future diagnoses — the dashboard makes this relationship legible to engineers and leadership.

The Before/After: What Memory Changes

The most concrete way to see what hindsight memory does is to compare what happens with and without it.

Without memory:

New alert: "Search service pods being repeatedly OOM-killed."

Dashboard shows: Alert received. No matching incidents found. Start investigation.

The engineer is on their own. They check pod logs. They look for recent deploys. They ask on Slack. Ten minutes pass.

With Hindsight memory active:

New alert: "Search service pods being repeatedly OOM-killed."

Dashboard shows: "85% confidence match. Similar incident: INC-0023 (March 14). Root cause: Memory leak in query result cache — unbounded growth under sustained read load. Fix: Rolling restart of search pods + QUERY_CACHE_MAX_SIZE=512MB env variable. Resolution time: 47 minutes. Lesson: Add memory threshold alert for search pods at 80% utilization."

The engineer knows exactly where to start. The context that would have taken 15 minutes of archaeology appears in seconds.

Resilience: The Local Fallback

A memory system that fails during an outage is a liability. Pulse addresses this with a dual-mode architecture.

During initialization, HindsightMemory tests connectivity to Hindsight Cloud with a timeout. If the cloud is reachable, all retain and recall operations go through the cloud. If the cloud is unreachable — which could happen precisely when your infrastructure is on fire — Pulse falls back to a local in-memory store with a TF-IDF cosine similarity implementation.

The local recall isn't as semantically powerful as the cloud, but it's fast, always available, and good enough to surface the most obvious pattern matches. During an active outage, something is better than nothing.

The source field in the diagnosis output ('hindsight-cloud' vs 'local') lets the UI indicate to engineers which mode is active — transparency about memory reliability during high-stakes moments.

What the Dashboard Surfaces

Beyond individual incident diagnosis, Pulse exposes system-level memory health metrics:

Memory Score — A percentage representing how much operational knowledge is encoded in the system. Scales with the number of resolved incidents in memory. A team that diligently resolves and documents incidents will see this score climb over time.

MTTR Tracking — Dynamic charts showing mean time to resolution across incidents, correlated with memory availability. The hypothesis: as memory depth grows, MTTR should shrink.

AI Reflection Panel — Per-incident, shows the full Hindsight reflection output: which past incidents were matched, what their root causes and fixes were, and the synthesized recommendation. Engineers can inspect the reasoning, not just the conclusion.

Memory Activity Feed — A real-time notification stream showing when incidents are retained, when memory is queried, and whether the system is operating in cloud or local mode.

The Deeper Idea

Pulse is built on a premise that's easy to state and hard to operationalize: an agent that can't remember isn't really an agent. It's a lookup table with a chat interface.

The engineering teams that respond best to incidents aren't the ones with the best dashboards. They're the ones with the deepest institutional memory — the engineers who've seen it all before, who recognize failure patterns before the postmortem is written, who know from experience that this particular symptom almost always has that particular cause.

Hindsight memory is how that institutional knowledge gets encoded in a system rather than locked in a person's head. Every incident resolved, every root cause documented, every lesson written down — it all goes into the memory bank. The next time something similar happens, the knowledge is there, queryable, immediately useful.

That's what makes Pulse different from a better PagerDuty. It's not a notification system. It's an institutional memory system that happens to handle notifications.

Tech Stack

Frontend: React, Vite, JavaScript
Backend: Express.js webhook server (Node.js)
Auth & Sync: Firebase Authentication + Firestore
Memory Engine: Vectorize Hindsight Cloud
Local Fallback: In-memory TF-IDF with cosine similarity
Monitoring Integrations: PagerDuty, Sentry, Datadog (via webhooks)
Real-time Delivery: Server-Sent Events (SSE)

Running Pulse

git clone https://github.com/krishnakasaudhan0/agent_memory_hackathon
cd agent_memory_hackathon/pulse

# Configure environment
cp server/.env.example server/.env
# Add VITE_HINDSIGHT_API_KEY and Firebase credentials

# Install dependencies
npm install

# Start the webhook server (in one terminal)
npm run server

# Start the frontend (in another terminal)
npm run dev

# Simulate an incoming alert
curl -X POST http://localhost:3001/webhook/sentry \
  -H "Content-Type: application/json" \
  -d '{
    "action": "created",
    "data": {
      "issue": {
        "title": "Search service pods being repeatedly OOM-killed.",
        "level": "fatal",
        "project": { "slug": "search-service" }
      }
    }
  }'

Watch the incident render in the dashboard in real-time, complete with an AI diagnosis pulled from memory.

Pulse was built for the Hindsight Agent Memory Hackathon. The live demo is available at pulse-nine-mu.vercel.app.

DEV Community: krishnakasaudhan0