Launched this week
N71
Give all your AI agents one shared context
181 followers
Give all your AI agents one shared context
181 followers
For knowledge workers orchestrating a dozen AI agents. 🧠 Your context never sits still: decisions shift, deals move, priorities change by the hour. Yet every new chat starts blank, and no agent knows what the others already worked out. N71 gives them one shared context that stays current, connect your tools and it maintains a living knowledge graph they read from over MCP, updated the moment anything changes. Ask any agent anything, and it's already caught up. 🔗
Free Options
Launch Team / Built With
N71
Hey Product Hunt 👋
I'm Mira, one of the co-founders at N71.ai 💜
N71 gives all your AI agents one shared context.
We built this for knowledge workers who run their day across a dozen different agents and are tired of starting from zero in every new chat.
If you're switching between Claude, Cursor, Codex, and every other agent, this is for you.
✍️ Here's how it works:
• Connect your tools in one click. Notion, mail, calendar, docs, chat, repos. Nothing leaves where it lives.
• We turn them into one living knowledge graph: your people, projects, and decisions, mapped.
• Plug your agents into it over MCP and keep working.
From then on, every agent you use reads from the same knowledge graph, and every answer traces back to its source.
Why you want N71:
Stop re-explaining: your context becomes a shared asset, not something you paste into every chat
Everything in one place: your tools, your history, your decisions, all connected
Every agent stays in sync: Claude, Cursor, ChatGPT or your own, all pulling from one graph
It thinks ahead: N71 surfaces what changed before you ask (gaps, contradictions, what moved this week)
Safe by design: every agent call is scoped, cited, and authorized, so nothing goes rogue
Shared context for every agent. Less re-briefing, less tool-hopping.
🎉 To celebrate our launch, use code PHLAUNCH to get 2 months off a Pro membership!
Come connect your first two sources and watch your context come alive. 🚀
@mira_charkawi The shared-read model is the dream — the part I'd push on is scoping.
In a single graph, "every agent reads from the same knowledge graph" and "nothing goes rogue" pull against each other. The moment a contractor's agent or some low-trust tool can query it, it can reach an exec-only decision or a customer's PII sitting three hops away.
Is authorization enforced at the node/edge level inside the MCP response — so two agents asking the same question get different sub-graphs based on who they're acting for? Or is scoping more at the connection level?
Curious how granular it gets, because "cited and authorized" usually breaks down exactly at row-level permissions.
Product Hunt
N71
@curiouskitty Great question! Short version: N71 learns your org's own vocabulary instead of forcing you into a fixed schema. New "nouns" only become real types once they show up repeatedly across your meetings, threads, and tools, so the graph stays clean instead of sprawling. And identity resolution runs on behavioral history rather than string matching, which is how renames and duplicates stay as one entity over time. We wrote up the full mechanics here if you want to go deep: https://n71.ai/research/tr-2026-03 🙌
The shared-read part is the easy win. The thing that bit us building a shared agent memory was write trust: one agent writes a stale or wrong fact and now every other agent confidently inherits it, so a single bad extraction quietly poisons the whole graph. Curious how N71 handles that, do writes carry provenance and confidence so a downstream agent can discount a shaky fact, or is a write just a write once the broker accepts it?
N71
@dipankar_sarkar A write is never just a write for us. Every fact an agent writes lands with a confidence score and a pointer back to where it came from, the source event, the snippet, who said it. So whatever reads it next gets the fact and its receipts together and can discount a shaky one instead of swallowing it whole.
Sensitive edges like customer_of or depends_on won't even write without evidence attached, so a bare claim just bounces.
Assert the same thing again and it bumps an evidence count instead of overwriting, so ten sources don't look like one random guess. And stale facts get versioned, the graph knows which version was true when, so old stuff gets retired instead of left fighting the new stuff.
That's the half most memory layers skip, so good to see writes carry receipts. The catch we ran into: provenance only pays off if the reading agent actually looks at the score, and most of them just grab the top fact and run. Does N71 down-rank or filter low-confidence facts in the MCP response itself, or hand back the fact plus its score and trust each agent to discount it? Enforcing it server-side was the only thing that stopped one shaky write from spreading for us.
N71
Promising direction. The hard product edge I would test is revocation: if a document, repo access, or customer thread is removed, can downstream agents still cite or answer from cached graph facts?
Shared context is only safe if permission changes and deletions propagate as first-class events, not just as better retrieval later. I would love to see the audit view expose the current answer, source freshness, and whether any source behind it has since been revoked.
N71
Re-explaining my project context every time I switch between Claude and another agent is genuinely one of the most annoying parts of the current workflow. A living knowledge graph that updates automatically when things change is the right direction — static docs go stale immediately. How does it handle conflicting information across sources when two tools say different things about the same project?
N71
@josedamian You just described the exact itch we built this for, the middleman tax of re-explaining context every time you switch agents. On the conflict piece: when two sources say different things about the same project, N71 keeps both, tagged with where each came from and when. It doesn't collapse them into one guess. The graph tracks how the fact evolved over time, so the current answer reflects the freshest, best-supported version while the older state stays visible and diffable. If the two genuinely can't both be true, that contradiction gets flagged for you to resolve rather than quietly picked for you. Every claim stays traceable back to its source, which is the part static docs can never give you.
Curious how this handles conflicting info when two agents surface different versions of the same fact at the same time, does the graph reconcile automatically or flag it for you to resolve?
N71