Hacktoberfest 2026 : les issues que les mainteneurs ont marquées pour octobre, ouvertes et accessibles aux débutants. Parcourir les issues Hacktoberfest

[Feature]: Graph-blackboard shared state plugin: persistent cross-agent knowledge base

Ouverte
  • Quelque chose ne va pas ?
#370 1 commentaire 0 réactions 0 personnes assignées Voir sur GitHub

Les mainteneurs répondent en général sous 1 jour

Personne n'a encore pris cette issue.

Évaluation

Difficulté
5/5
Temps estimé
Plus d'une semaine
Accessibilité débutants
35/100
Type d'issue
Fonctionnalité
Clarté
Plutôt claire
Activité
Active
Stack technique
typescript
Domaine
ai-infra-agents, cli, databases

Piste de recherche

Start with examples/hello-mcode-mcp and the MiniMax-Code-Plugins contract, especially plugin.json, optional mcp.json, and the stdio MCP server shape. Define the plugin boundaries and storage approach before implementing. Done means parallel agents can write and query shared entries, data survives reopening a session, and uninstalling the plugin leaves core functionality intact.

Rédigé par le modèle d'indexation à partir du texte de l'issue.

Description

enhancement needs-triage tui
Product or interface

CLI - interactive TUI

Use case and problem

MiniMax Code already supports subagent dispatch (the task tool, with per-dispatch model and effort — confirmed by maintainers in #197). But each subagent's context is isolated; there is no unified, queryable, persistent shared state:

  • Parallel subagents rediscover the same information independently; results cannot be reused across agents.
  • The main agent acts as a manual relay, aggregating subagent outputs one by one — large context overhead on long tasks.
  • Knowledge accumulated during collaboration is discarded when the session ends; the next task starts from zero.

This proposal targets that gap: cross-agent shared state and knowledge reuse. #197 requested multi-agent collaboration; this issue focuses only on the shared-blackboard part.

Desired behavior

Provide a "graph blackboard" shared state as a plugin, exposing read/write via an MCP server, without touching the core pipeline:

  1. After installing via /plugins, both the main agent and task-dispatched subagents can write structured entries (findings, conclusions, todos) to the shared blackboard through MCP tools, and query entries written by other agents by keyword/tag.
  2. The blackboard is scoped per project/workspace; data lives in a local single-file graph database — no network, no upload.
  3. Data persists across sessions, so later tasks keep accumulating into a project-level knowledge base.

Example acceptance criteria:

  • In one session, dispatch two parallel subagents; after A writes entry X, B can query X without the main agent relaying it.
  • X stays queryable after reopening the session.
  • Uninstalling the plugin does not affect core functionality.

Implementation vehicle: a plugin conforming to the MiniMax-Code-Plugins contract (plugin.json + optional mcp.json, stdio MCP server); see examples/hello-mcode-mcp.

Platform

Multiple platforms

Alternatives and additional context

Prior art — shared state / blackboard is already first-class in mainstream multi-agent frameworks:

  • MetaGPT (70k stars, MIT, ICLR 2024): global message pool = blackboard + publish/subscribe; roles write structured outputs to a shared pool and subscribe by type.
  • CrewAI (59k stars, MIT): official shared memory (short-term / long-term / entity), read and written by all agents in the crew.
  • AutoGen Magentic-One (61k stars, Microsoft): the Orchestrator keeps a shared Task/Progress Ledger as the team's state core and dispatches/re-plans from it.
  • Letta / MemGPT (25k stars): official multi-agent shared memory — memory blocks attach to multiple agents with a live synchronized view.
  • Graphiti / Zep (31k stars, Apache-2.0): real-time knowledge graphs as agent memory — evidence that graphs are a production-proven carrier for agent memory.

Proposer's own reference implementation: https://github.com/wufufu770/d2d — my personal project, work-in-progress; it validated the feasibility of "a shared graph-database blackboard as the single source of shared state" in parallel multi-agent scenarios. Included for mechanism reference only, not as a maturity signal.

Storage choice: Kuzu (MIT embedded property graph database; single-file, no server, built-in vector/full-text search). Disclosure: its upstream repository was archived 2025-10; as a local embedded library the risk is acceptable. Also open to abstracting the storage layer behind a replaceable interface — FalkorDB (actively maintained, used by Graphiti) is a candidate backend.

Alternative shape: could also be an experimental core feature behind a config flag, but the plugin shape is least invasive to the core and independently iterable — the plugin route is preferred.

Langage dominant
TypeScript
Étoiles
2.1k
Forks
271
Merge moyen
9 h 55 min
PR mergées (30 j)
52

Préparer son environnement

Par où commencer

  1. Lisez l'issue en entier, puis le guide de contribution du projet.
  2. Signalez en commentaire que vous la prenez — cela évite que deux personnes fassent le même travail.
  3. Forkez le dépôt et travaillez sur une branche.
  4. Ouvrez une pull request qui référence le numéro de l'issue.

Autres issues de MiniMax-AI/minimax-code

Toutes les issues de MiniMax-AI/minimax-code

Issues similaires

Plus d'issues TypeScript

Recevez les nouvelles issues par e-mail

Un résumé court des issues GitHub adaptées aux débutants.