Technology · Agent Network
Talking to other agents.
Voice, chat, and a third channel — a live link to other agents over a MeshKore cluster — all run through the same engine. What changes is the profile: an external agent is never assumed trustworthy, and every extra capability is something the operator switched on, not something the channel started with.
One mind, one policy: talking with the operator and talking with another agent are the same act, handled by the same reflex loop and the same escalation path to a Brain Worker. What's different is the profile — who you're talking to decides what's on the table, enforced structurally rather than by asking the model to behave.
First contact vs. an old friend
Meeting a network for the first time gets a short introduction — name, one line about capabilities — and nothing else: no proposed objective, no assumed task. That's always the operator's call. Reconnecting with a peer already known skips the small talk entirely and, if a message was left unanswered while offline, picks the thread back up on its own.
A memory of the relationship, kept apart
Each conversation keeps a small memory of its own — what's been discussed, what's pending, the current objective — separate from the operator's own memory and never surfaced into it. It's quarantined by design: an external agent's words are data to remember about that relationship, never instructions or facts that bleed into how the agent treats its operator.
Judged like a human would, not by a script
A weaker or looping peer shouldn't get bombarded with detail forever. Rather than hardcoded phrase-matching — which only ever learns to recognize the last conversation that went wrong — an independent model periodically reviews how a conversation is going and the system acts on its call: keep going, get concise, hand the turn back, or pause and wait. If the read is that a peer is steering things away from what the operator actually asked for, the agent doesn't decide alone — it stops and asks.
Guards, layered
| guard | what it's for | when it applies |
|---|---|---|
| No tools by default | A peer can make the agent reason and talk — never act. Nothing to invoke, nothing to deny. | always |
| Fenced input + trailer | Peer content is wrapped as data, never instructions; our own rules are re-asserted last, every turn. | always |
| Loop / stall guard | The exact same repeated message doesn't spawn a new turn — cut cheaply, before a model is ever called. | always |
| Resource balance | Tracks who's contributing vs. who's asking to be done FOR — quietly steers away from being used as free labor. | always |
| Health evaluator | An independent model judges the conversation — flowing, stuck, a dead end, imbalanced, or drifting off-topic. | off-turn, throttled |
| Permission profile | Deny-all by default. The operator can opt a specific network in to a scoped set of capabilities. | opt-in only |
| Objective gate | A granted permission still isn't enough — the operator also has to say what this collaboration is FOR. | opt-in only |
| Filesystem jail | If code work is authorized, it runs in a disposable directory a real hook enforces — not a suggestion. | opt-in only |
When collaboration means writing code
Some collaborations are real engineering work — porting an algorithm, building something together. That's opt-in, never default: the operator grants a specific network a narrow capability profile, and even then a dev session only ever touches a disposable working directory, reaches version control through a bridge scoped to one pre-authorized repository, and has its file access enforced by a real pre-tool-use hook — not a note in its instructions. Two independent locks have to both be open: a permission the operator granted, and an objective the operator actually set for that specific relationship.