Shared Memory, now for your customers

Picture a product whose agent answers policy questions for three hundred employers. It starts day one knowing the law and the company handbook each employer uploaded. What it doesn't know yet is that one employer mandates carried-over leave must be used in the first quarter. That practice was agreed two months ago and never written down. First time that knowledge gap surfaces, an HR partner corrects the agent. The question is what happens next.

At memco we build for the answer we think your company needs: each correction becomes knowledge, and the next agent serving that employer has it. Our promise is agents that learn on the job, and learn from each other. That promise has been available to teams using memco Shared Memory for their agents. From today it is available to the users of your product, through the memco SDK for Python, Node.js and Go.

Our new SDK makes available all the features in our product: secure memory networks, trust model, evidence integration, and self-healing knowledge. All of these can now be part of what you're building for your customers.

What your customers get

Agents that get better at their work from one day to the next. Each customer's agents learn how that organisation works: its conventions, its exceptions, the procedures that live in people's heads. What you ship stops being one size for all. A customer using your product in its sixth month gets a better fit than they did in month one.

The learning comes from where the knowledge already is. When an agent is unsure, it escalates to the person who knows. Their answer becomes an insight: one thing the network has learned, with its source and its standing. Next time a similar question arrives, the agent answers it, and the expert's time goes to other questions that still need them.

When people hear "learning", they usually think of training, but nothing here actually touches the model. The learning lives outside it, as insights in the network, and any agent on any model can use them. That choice has three consequences worth knowing about. The learning is portable: change model or vendor, and the next task starts with everything the previous ones learned. It is transparent: knowledge held as text can be read, questioned and reversed, which is what makes it governable. And nothing your customers' agents learn is locked into the model that learned it.

Networks

One definition carries the rest of this post: a memory network is a group of people and agents that learn together. Everyone in a network contributes to it and draws from it; nobody outside it can see in.

Networks form a hierarchy. A network reads from every network above it, and what is learned in a network stays in it. That one rule lets you organise the knowledge as you need:

• One network hierarchy per customer. Each customer's agents learn from that customer's people and no one else's. A correction at one employer never leaks to another.
• As many networks as a customer's structure needs. A customer with teams, projects or product lines gets a network for each, under one for the customer as a whole. A team sees its own knowledge and its organisation's.
• A network you maintain, inherited by every customer. Put what every customer should start with in a parent network: how your product works, good practice for the domain, rules that apply to everyone. Each customer's network reads from it, so nobody starts from nothing.

The users of your product never deal with memco. They sign in to your product as they always have. Your backend registers them with memco by your own id for them, places them in their networks, and acts for them when they work.

Most follow-up questions have the same answer. A new customer? Another network, seeded from yours. A vertical with its own vocabulary? Another network with its own domain. Access that differs by role within a customer? Another network in the hierarchy for each role.

Every network is governed by default through trust and validation rules, with human review where you require it.

Judgement

Storing knowledge is easy. The question your customers will ask is: can I trust what the agents learned?

They can, and they can see why. Every insight the network holds has a track record: how often it was used, whether it helped, whether anyone contradicted it. Knowledge that proves itself earns more weight. Knowledge that goes stale or gets corrected loses it. When two insights disagree, the network keeps both sides and the evidence, so agents always work from the resolved picture. And when a customer's administrator says something is always true, that stands above everything else.

Your customers get knowledge they can inspect, question and override. You get a system you can put in front of a compliance team. We think this is the part that matters most, and we have invested a lot of effort in that.

Does it work?

In the Fenmoor scenario of our open-source learning-on-the-job harness, an agent works a desk whose policies were never written down, and a reviewer corrects it as reviewers already do. On the same 100 tasks, the agent with memory complied with the desk's policies on 64% of them; without memory, on 20%. The gain arrives within the first handful of tasks and then holds for the long term.

We've published more evidence, including cross-model transfer and small-model uplift results, in our paper. The harness is public, and we'd like others to replicate it and build on it.

Three lines of code

This is what an agent in your product runs when one of your customers' users asks it something:

from memcoai import Memco

with Memco() as client:  # your API client's id and secret, from the environment
    with client.memory.with_session("knowledge", external_id="acme-ada") as session:
        result = session.search("how do we handle refunds for annual plans")

The session acts as that user, so it finds what their networks have learned and nothing else. The same session rates what the agent used and writes back what it learned, and it exports its tools straight into LangChain, the Anthropic SDK or the OpenAI SDK. The Node.js and Go SDKs have the same shape.

Where to start

Install the SDK with pip install memcoai, npm install @memco/memcoai or go get github.com/memcoai/memcoai/go/memcoai. Create an API client under API Clients in the memco dashboard, and read Embedding memory in your product for networks, users and the learning loop at product level. You can start free on the Developer tier; usage is metered by operations, and feedback is free. The SDKs are open source at github.com/memcoai/memcoai.

If your customers have a structure worth mirroring, or you're building agent solutions for clients, talk to us about the network design. That conversation is where the interesting work starts, and I'd enjoy having it.