AgentHelm
Shared memory & coordination layer for AI agent teams
9 followers
Shared memory & coordination layer for AI agent teams
9 followers
AgentHelm gives multi-agent AI systems a shared brain instead of siloed memory. Built on open protocols (MCP, A2A) — not a custom lock-in transport. ✅ Memory Handoff: persistent reasoning continuity across agent runs ✅ Agent Presence: real-time coordination between agents ✅ Python SDK (primary) + Node SDK ✅ Published on PyPI & npm ✅ Drop-in, single line of code to integrate. Built for teams tired of agents that forget everything between sessions..
This is the 2nd launch from AgentHelm. View more
AgentHelm
Launched this week
AgentHelm gives every AI coding agent a shared Project Brain — so Claude Code, Cursor, and custom agents all remember the same architecture, APIs, and decisions instead of starting from scratch each session. Unlike per-agent memory tools, it's one shared brain across unlimited agents. Built on open protocols (MCP, A2A), not a proprietary lock-in format. One Project. One Brain. Unlimited AI Agents
Free Options
Launch Team / Built With
Hey Product Hunt 👋
I’m Tharagesh, founder of AgentHelm.
I kept running into the same problem while working with multiple AI coding agents: one agent makes an important decision — changes an API contract, updates a database schema, chooses an architecture — and another agent working on the same project has no idea it happened.
The agents are intelligent individually, but the project itself has no shared memory.
That’s why I built AgentHelm.
AgentHelm is a shared, versioned project memory layer for AI agents. It gives agents working across different sessions and tools a common source of truth, so project knowledge belongs to the project, not to any individual agent.
Here’s what you can do with AgentHelm:
🧠 Give agents a shared Project Brain
Agents can retrieve relevant project context before starting work and contribute important knowledge when they're done. Decisions, architecture, API contracts, schemas, and other project knowledge can persist across agents and sessions.
🔄 Share context across different agents
Whether your agents are running independently or as part of a multi-agent workflow, AgentHelm provides a common memory layer so they can work from shared project knowledge instead of isolated context windows.
🛡️ Prevent agents from silently overwriting knowledge
Instead of treating every new piece of information as automatically correct, agents can submit knowledge proposals that go through a controlled compilation process before becoming part of the Project Brain.
📚 Keep project knowledge versioned
AgentHelm takes inspiration from Git. As project knowledge evolves, you can preserve its history and understand what changed instead of simply replacing old context and losing the reasoning behind previous decisions.
⚠️ Detect stale and conflicting knowledge
As the project evolves, previously correct information can become outdated. We're building AgentHelm to identify potentially affected knowledge and prevent agents from blindly relying on stale assumptions.
👀 Understand what your agents know
We're working toward memory observability that lets developers inspect what context an agent received, where it came from, which version it used, and how knowledge moved between agents.
🔌 Integrate without replacing your agent stack
AgentHelm isn't trying to be another agent orchestrator. The goal is to provide the shared memory and governance layer underneath the agents and tools developers already use.
The idea behind AgentHelm is simple:
Knowledge should belong to the project, not the agent.
If multiple AI agents are going to work together on real software for days, weeks, or months, they need more than isolated context windows. They need a shared understanding of what the project currently knows — and a way to safely evolve that knowledge over time.
AgentHelm is still evolving, and feedback from developers here has already influenced what I'm building next.
I’d genuinely love to hear from anyone running multiple agents: How are you handling shared context and memory today? What would make AgentHelm useful enough to become part of your workflow?
Thanks for checking it out and supporting AgentHelm 🙌
— Tharagesh, founder of AgentHelm
honestly this looks really useful, been wrestling with agents losing context between runs for a while. one thing that would be a big win is built-in observability for the memory handoffs, like a small dashboard or CLI command to inspect what state each agent is holding and trace why a handoff failed. would save a ton of debugging time when chains go sideways.
@berendmy1 Totally agree. Shared memory becomes hard to trust if you can't see what each agent actually knew at a given point. I'm working toward exactly this a memory inspector and handoff timeline where you can see what context an agent received, where it came from, which brain version it used, and what it passed on. The goal is to make debugging agent memory as transparent as debugging logs or traces
@berendmy1 Really glad to hear that! Keeping the integration lightweight is one of the main goals .I don't want developers to have to redesign their agent architecture just to get persistent shared memory. Would love to hear how you're using it in your Python stack and anything that felt missing or could be simpler.
Love the open-protocol stance and the single-line integration is genuinely appealing. One thing I'd want to see soon is a built-in dashboard or CLI to inspect what each agent currently "remembers" and which handoffs happened during a run, otherwise debugging cross-agent memory drift in production will be painful.
@ouzsqnu Yeah, this is a really good point. I'm thinking about observability specifically around memory rather than just generic agent logs basically being able to answer "what did this agent know when it made this decision?" and trace the context handoff between agents. A CLI for quickly inspecting an agent's context and tracing failed handoffs would be really useful too. Definitely something I'm prioritizing.
Memory handoff between runs actually works, finally my agents stop forgetting mid-project. Loved how it slotted into my python stack with just that one line change.