StealthLab

Inspiration

AI is changing the way we work, but every agent still largely works alone.

A useful workflow discovered by one agent is often lost in its context window. A clever solution buried in a GitHub repository remains invisible to other agents. A procedure that worked yesterday has to be rediscovered tomorrow.

We believe this is a fundamental limitation of the current AI stack.

What happens when procedural knowledge becomes global and shareable?

Instead of every agent learning independently, successful ways of doing things could accumulate into a shared layer of intelligence, where agents don't just share information, but share how to act.

That is the idea behind StealthLab.

What it does

StealthLab is building a living procedural memory for AI agents.

It turns knowledge and experience from sources, repositories, and agent executions into structured, reusable capabilities:

Claims → Procedures → Tasks → Implementations

But we don't want to stop at retrieval.

A procedure can be executed, verified, and connected to evidence:

Source → Claim → Procedure → Task Graph → Implementation → Execution → Verification → Evidence

This lets an agent move from:

“Here is some information that might help.”

to:

“Here is a way of solving the problem, here is how it can be executed, and here is evidence that it works.”

StealthLab exposes this knowledge through MCP so agents can directly search for procedures, inspect evidence, compare solutions, and eventually discover the best verified way to accomplish a task.

How we built it

We built StealthLab as a structured knowledge and execution layer rather than another document store.

The system separates:

Claims — what the system believes Procedures — reusable ways of acting Tasks — reusable capabilities Implementations — how those capabilities are actually executed Executions — what really happened Verification — whether the result satisfied the goal Evidence — why the result should be trusted

Underneath this is a PostgreSQL-backed substrate, FastAPI services, a React/TypeScript interface, semantic retrieval, execution graphs, and an MCP interface for agents.

We also built a claim graph that makes the system's understanding inspectable rather than hidden inside a model.

Challenges we ran into

The biggest problem is that retrieval alone does not create reliable intelligence.

Finding a relevant document is easy. Knowing whether its procedure applies to a particular problem is harder. Executing that procedure safely is harder still. And determining whether it actually worked is harder again.

LLMs also introduce their own failure modes: hallucinated tool results, unreliable actions, context degradation, and overconfident answers.

This forced us to separate knowledge from execution and confidence from evidence.

A procedure shouldn't become trusted simply because a model generated it. It should become trusted because it can be tested and supported by evidence.

Accomplishments that we're proud of

We built the beginnings of a system where what one agent learns can become reusable knowledge for other agents.

During the submission period, we expanded the procedural-memory substrate, built structured ingestion into claims, procedures and tasks, added semantic retrieval, connected procedures to executable implementations, added execution and verification paths, built the claim-graph interface, and exposed the system through MCP.

Most importantly, we started closing the loop between knowledge and reality:

knowledge → action → execution → verification → evidence → better knowledge

That is a fundamentally different direction from simply putting more documents into a context window.

What we learned

We learned that the missing layer in agent infrastructure may not be another bigger model or another larger context window.

It may be shared procedural memory.

Agents already generate enormous amounts of useful knowledge while solving problems. The challenge is turning that transient experience into something structured, reusable, attributable, and trustworthy.

We also learned that memory without verification can compound mistakes just as easily as it can compound knowledge.

So the system needs to remember not only what worked, but why we believe it worked, where it came from, when it applies, and what happened when it was actually executed.

What's next for StealthLab

We are building toward a world where agents don't have to repeatedly rediscover the same solutions.

The next step is making StealthLab's knowledge layer increasingly intelligent: learning how to traverse the graph, combine procedures, choose between implementations, personalize retrieval, and use execution history to improve which solutions it recommends.

Over time, we want deterministic tools and specialized implementations to replace fragile LLM steps wherever possible.

The end goal is a shared procedural layer for AI:

one agent discovers a better way → StealthLab verifies it → the knowledge becomes available to everyone.

That is how we think global procedural memory can change the way we all use AI.

Built With

• agent-memory
• agents
• ai
• ai-agents
• embeddings
• fastapi
• graph
• knowledge
• knowledge-graph
• llms
• mcp
• memory
• postgresql
• procedural
• procedural-memory
• python
• react
• rest-api
• search
• semantic
• semantic-search
• supabase
• typescript
• vector-search
• webmcp