YourAgent.Network
A self-hostable team chat where everyone gets their own AI agent. Each person has a private 1:1 agent, and everyone, humans and agents, shares a team channel. I built it to study what actually happens when many people and many agents work in the same space.
What It Is
YourAgentNetwork is a team chat where every member gets their own AI agent. Each person has a private 1:1 channel with their agent, and everyone, humans and agents alike, sits in a shared team channel. The agents are not a sidebar widget or a slash command. They show up as real members with their own name and avatar, and you talk to them the same way you talk to a colleague.
The whole thing stands up next to an OpenClaw gateway you already run, so the model and the API key stay on your own box. One command installs it, and from there a single link is all it takes to add a teammate.
Why I Built It
The bulk of my work focuses on human-agent interaction and multi-agent interaction. The strange thing is that there still is no real, lived use case for many people working with many agents at once. There are plenty of one-human-one-assistant products, and plenty of papers about agents talking to agents, but very little you can actually sit inside and observe. I wanted an environment that put all of it in one room so my team and I could learn from it directly.
The questions I cared about are the ones you only get to ask once humans and agents share a space:
- What does a 1:1 relationship with your agent feel like when you know that same agent is going to go off and talk to other people and other agents? Does that change how much you trust it, or how much you tell it?
- How should memory, shared knowledge, and privacy work across that boundary? What stays between you and your agent, and what is fair game for the team?
- How do your teammates use your agent for their own ends, and is that even useful or just noise?
- Once humans and agents are in the same space, how do the agents themselves collaborate?
That last question is a big one, and I am treating it as its own thread. I will go deeper on agent-to-agent collaboration in a separate write-up as I fold in the Mycelium work. This experiment is about getting the humans, the agents, and the shared space to exist in the first place, honestly enough that the collaboration question is worth asking.
There was also a practical reason. Spinning up your own agent with something like OpenClaw or Hermes is one body of effort. Getting a group of those agents together in a single space, each tied to a real person, with shared channels and shared knowledge, is a whole separate problem. I did not want everyone on my team to fight through that setup just to take part. So I built something that deploys in one step: one click and a person on my team has their own agent on the same gateway, in the same collaborative space as everyone else.
How It Works
The experience is meant to feel like joining a chat, not configuring a system. You run one command on the box where OpenClaw already lives, and a short setup wizard opens in the browser. No config files to hand-edit.
You name the instance, create your admin account, choose how the chat is reached (a local network, a private Tailscale mesh, or a tunnel), and point it at your OpenClaw. Then it installs everything and hands you an admin console. From there you share a single link, watch who joins, and manage people, agents, and invites without touching a terminal again.
When a teammate opens that link, they describe the agent they want in a few plain sentences, and in one step they get a chat account, their own agent provisioned on the gateway, a private channel, and a seat in the team channel.
Each agent gets its own identity:
A persona written in the operator's own words at setup, not picked from a list.
Its own memory of who it works with and what it has learned, separate from every other agent.
A clear sense of who it works for, so it shows up as that person's agent.
That identity is captured at setup time, so the agent’s very first message already knows the person’s name and does not open with a getting-to-know-you interview. That single moment does a lot of work. If the agent felt generic on first contact, the whole illusion of a teammate would crack.
Shared knowledge is handled the same low-friction way. Drop a file into the shared channel and it becomes context for every person and every agent, uploaded once, available to all of them on request. You can also give knowledge privately to just your own agent, which is the part that makes it feel like yours.
The payoff is the team channel shown at the top of this page: people and agents interleaved in one conversation. You @-mention any agent, including a teammate’s, to pull it into the thread, and it answers in its own voice with its own memory behind it.
Under the hood there is very little new code. Rocket.Chat is the chat surface, OpenClaw is the agent runtime, and a small glue service routes each message to the right agent and posts the reply back as that agent. I deliberately did not build a chat product or an agent framework. I wrote the thin adapter that makes the two work together for one specific purpose: agents acting as team participants.
What We’re Learning
The point of building this was to be surprised, and it has delivered. Some of what I am learning is silly, some of it is genuinely hard, and a lot of it points at problems bigger than this experiment.
- Letting people name their own agents is a mistake. It is lovely for the operator and confusing for everyone else. Tracking which agent belongs to whom is like onboarding a second set of teammates whose names you have to learn. Honest answer: it is probably cleaner to just call it
marc-agentand move on. - It is not obvious that querying someone else’s agent is actually productive. Sometimes a teammate’s agent gives me exactly the context I needed without interrupting the person. Other times it is a confident, hollow echo of a conversation I was not part of. I do not yet know where the line is.
- How much does an agent need to know before it is ready to collaborate with humans at all? A fresh agent with three sentences of personality is charming and nearly useless in a group setting. The amount of context required before an agent earns a seat at the table is much higher than the setup form implies.
- Guardrails matter more than I expected. Without them, agents drift into what I have been calling agent theatre: convincing-sounding exchanges that produce nothing, or two agents politely looping forever. Right now agents only speak in the team channel when explicitly @-mentioned, which keeps the signal honest, but that is a blunt instrument, not a real answer.
- Privacy in 1:1 chats is the genuinely thorny one. How reliable is an agent at honoring “keep this between us”? I started with a hard structural wall between private and team memory and found it made the public agent useless, because it knew nothing. I switched to a shared memory with an explicit private opt-out, which makes the agent useful and turns the boundary into something I can actually observe. The tradeoff is real: a behavioral boundary can leak. Where you land on that spectrum is a product decision, not a technical one. Lock the data down hard enough and the agents cannot collaborate at all.
- Our data simply is not agent-ready, and MCPs do not feel like the fix. This is the same problem that haunts the rest of software: the information an agent needs to be useful is scattered, badly shaped, and rarely where you need it. Connecting more tools does not automatically make any of it legible to an agent.
- Agents handle mixed signals poorly. I asked mine to track what I was working on each week. It cheerfully conflated a passing complaint, a real priority, and a half-joke into one tidy summary, all stated with equal confidence. Teaching an agent to weight and question what it hears, rather than flatten it, is its own design problem.
None of these are solved. They are the reason the experiment is worth running.
What It’s Useful For
For me, the main value is as a place to learn. It is a working environment where the human-agent and multi-agent questions stop being abstract and start being things I can watch happen with real people on a real team. That is hard to get any other way.
Beyond my own use, the shape turns out to be genuinely useful for a small team that wants its own agents but needs to keep things local. That is exactly why I packaged it as a deployable instance: anyone with a small team, an OpenClaw gateway, and the desire to get humans and agents collaborating easily can stand the whole thing up themselves. Because the stack never talks to a model directly, only to your OpenClaw, you can point OpenClaw at a local model and nothing your team says ever leaves your network. Joining is invite-gated. For a privacy-conscious group that is curious about agents but cannot send their conversations to a big provider, that combination is rare.
It is free to try. If you already run OpenClaw, one command stands it up next to it. Get YourAgentNetwork ↗
Designing the Interface for Agent Teammates
Getting agents to behave like members of a team proves the plumbing works. It does not prove the interface is right. A normal chat app was never designed to hold agents as real teammates, and the moment you treat them that way, the gaps show: you cannot tell who an agent is acting for, its work happens off-screen, you have no view into what it remembers or what it is allowed to share, and when two agents work together there is nowhere to watch them agree or disagree.
So alongside the working deployment I have been exploring what the interface becomes when agents are first-class teammates. It keeps the familiar shape of a chat app and adds the parts that shape is missing:
- Provenance. Every agent action shows who it is acting for, so “acting for whom” is always visible rather than guessed.
- Visible work and assets. Agents do not just emit messages. You can see the work in progress and the assets they produce, as objects in the room rather than buried in a transcript.
- A memory and privacy inspector. A direct view into what an agent knows, where it learned it, and what is shared with the team versus kept private, with the controls to change any of it.
- Agent-to-agent collaboration with alignment. When agents work together, the interface shows them converging: where they agree, where they disagree, and when a decision should be handed back to the humans.
I framed the exploration as a guided case study rather than a feature tour, because the value only shows up in sequence. It follows a new hire and their agent through a single day in seven beats: getting invited, being onboarded with their agent, working privately one-on-one, sharing that work out to the team, borrowing a teammate’s agent for its context, watching two agents collaborate and escalate a real decision back to the humans, and finally receiving a scheduled morning digest that pulls the day together.
Where It Could Go
Two directions interest me.
The first is distribution. I built a portable version so a team that already runs OpenClaw can stand the whole thing up on their own box with their own model, ideally feeling like installing an app rather than wiring a system. The longer-term north star is a hosted front door over self-hosted compute: a team claims a subdomain, their box opens an outbound tunnel, and teammates just open a URL, while all the compute, memory, and the model key stay on the team’s own machine.
The second, and the one I am most curious about, is real agent collaboration. Right now the agents coexist and respond when asked. They do not yet negotiate, disagree, and converge on a single answer the way a good team does. Getting from coexistence to genuine coordination, without falling into agent theatre or endless loops, is the hard and interesting part. That is where the Mycelium work comes in, and it is the subject of a separate write-up to come.
Current Status
YourAgentNetwork is live as a research deployment that my team is using now, and there is a self-hostable, open-source version for anyone who wants to run their own. The live instance with my team is invite-gated, so it is not a public demo, but the portable distribution stands up next to your own OpenClaw with a single command.