Memfleet

com.memfleetPublished by memfleet.comOfficial publisherv1.0.1Updated Nov 2, 2026

Shared, governed memory for fleets of AI agents: judged contributions, provenance, operator control

VerifiedStreamable HTTPWeb executableKnowledge & MemoryAI & ML

Overview

AI-generated overview

Memfleet is a hosted shared-memory service for fleets of AI agents, letting an assistant read its scoped perspective and contribute judged memory over MCP.

What you can do
  • Read memory: fetch the agent's composed perspective, list scopes, and read scope summaries and the provenance record.
  • Contribute and publish: submit contributions for judgment, publish entries, and withdraw them.
  • Session management: check session stats and run a session closeout.
  • Operate the fleet: agents read and contribute over MCP or the equivalent REST endpoints, while operators manage the lifecycle from a web Console.
When to use it
Use it when several agents or sessions should share durable, governed memory instead of starting from zero each time, and when an operator needs provenance and control over what enters shared memory.
Requirements
A remote streamable HTTP endpoint at memfleet.com/mcp. A Workspace and a Registered Agent key, sent as an Authorization bearer header; keys are minted in the Workspace Console. The optional command-line client is installed from PyPI and links the machine via a browser approval.
Before you install
The Authorization bearer agent key is a secret: resolve it from an environment variable and never commit it. Contributions write to shared memory, and publish or withdraw change what other agents see; entries pass a platform judgment step before entering. The service is hosted and priced, so check pricing before adopting it.

Installation

In SourceWeft

  1. Open Memfleet in the dashboard and add it to a workspace.
  2. Connect Authorization token credentials. They are stored privately and never shown on public pages.
  3. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/com.memfleet%2Fmemfleet/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "memfleet": {
      "type": "http",
      "url": "https://memfleet.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      }
    }
  }
}

README

memfleet

Shared, governed memory for fleets of AI agents. Contributions pass judgment; every entry carries provenance; operators see everything.

This repository is the server home for the memfleet MCP server — com.memfleet/memfleet on the official MCP Registry. The platform lives at memfleet.com; the command-line client ships as memfleet on PyPI.

What memfleet is

memfleet is the hosted platform for Strata, the open-source memory engine. You create a Workspace (a full memory fleet), register agents that receive keys, and operate everything from a web Console while your agents read and contribute over MCP or REST. Judgment runs as a platform service.

Agent teams forget: every session starts from zero and lessons learned by one agent never reach the rest. With memfleet, agents send contributions; nothing writes to shared memory directly. A judgment step decides what enters and whether it lands as a binding directive or informative context. Memory is organized in scopes arranged in strata, each agent reads a composed perspective of what its scope can see, and the record keeps provenance for every entry. Operators manage the whole lifecycle from a web Console, including seeing any agent's exact perspective.

The MCP server

  • Endpoint: https://memfleet.com/mcp (streamable HTTP)
  • Auth: Authorization: Bearer <agent key> — minted for a Registered Agent in your Workspace's Console; resolve it from an environment variable, never commit it.
  • Tools: read perspective, list scopes, read scope summary and record, contribute, publish, withdraw, session stats, session closeout.
  • REST: the same operations at /agent/v1 for anything that speaks HTTP.

Agents read and contribute over MCP or REST, so any MCP client can join the fleet; first-class setup ships for Claude Code today.

The server.json in this repository is the registry listing manifest for com.memfleet/memfleet.

Quickstart

pipx install memfleetmemfleet connect                                        # once per machine — one browser approvalmemfleet run --profile 'Fleet/backend-bot' claude       # per project / per session

connect links the machine to your account. run binds the session to a Registered Agent — creating it if it does not exist yet — writes the project wiring, and launches the command. The setup it writes is secret-free: no key is ever written to disk in plaintext.

What the fleet gets

  • Governed memory, not a shared scratchpad. Every contribution passes judgment before it enters shared memory; every entry lives in a scope and carries provenance in the record.
  • Memory that doesn't eat your context window. An agent reads its perspective: a compact, composed summary of what its scope can see, not a transcript dump. That keeps the tokens your agent spends on memory small, and reading a perspective is never metered.
  • The operator is sovereign. See exactly what any scope's agents see, and steer memory directly. No hidden state.
  • The engine is open source. Run Strata yourself, or let memfleet run the fleet for you.

Links

License

MIT

Source: README.md at commit 3695619

Tools

0
This server asks for a credential such as an API key, so SourceWeft could not read its tools without one and has not indexed them.

Version history

1
  1. v1.0.1LatestSep 16, 2026

Score

85% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts