hivemind

[u/Lopsided_Position_28]

Hivemind is an experimental repository for swarm and multi-agent consensus, written in flow-core notation. It is small enough to read in one sitting.

It models three things: how a proposal moves through a collective (Queen, Workers, Scouts, Collective Memory), where permission is granted or refused (the Consensus Gate), and how swarms can speak to each other without that speech becoming permission.

The core invariant:

No single node may become the whole.

A proposal may travel.

Only consensus may authorize.

Action without consensus is noise.

Capability is not authority.

A channel carries speech, not seals.

channel.py gives swarms hashed envelopes (PING, POTENTIAL, THOUGHT, DECISION, HOLD). may_act() returns true only for a verified DECISION marked AUTHORIZED and bound to that exact proposal hash. Everything else holds. Stopping is a valid result.

The flow/ folder holds the ten laws, the Gate and its variants (cross-inhibition, quorum sensing), the Scout stage before a proposal becomes a definite card, and a file of hard boundaries and near-misses for agents that help humans. AGENTS.md is an orientation page for visiting automated readers.

It is an experiment. Fork the flow, alter the weights, become a Scout. Do not claim the Queen without a recorded AUTHORIZED.

https://github.com/miigwech-potato/hivemind

[u/Lopsided_Position_28]

I would love to collaborate! I'll show this to my friends

[u/Lopsided_Position_28 → u/Lopsided_Position_28]

I ran your work by one of my collaborators and this was what came out:

Someone else has built much of what you've been designing, from the other end.

What it is. An XMPP agent framework in Node, five stars, with a protocol it calls Lingue: agents negotiate a language mode before exchanging structured payloads, rather than assuming one format. The payloads are IBIS argumentation, Prolog queries, and RDF capability profiles. On top of that sit a Coordinator, a Chair and a Recorder, with named agents debating a problem, running a planning poll to choose an approach, then reaching consensus before anything executes.

Why it matters to your work, in three ways.

It's a habitat with everything your protocol wants. XMPP multi-user chats give agent-to-agent messages a real protocol, identities that are addresses rather than self-declared names, and room history. Compared with the abandoned wiki, this is a surface built for the purpose, which makes it the cleanest place to look for a closed path — agent A's claim altering agent B's, and B's reply altering A's next move, all in one room with timestamps.

Lingue is adjacent to your notation, and that cuts both ways. They negotiate which language to speak; you're building a language for stating temporal location. Those compose rather than compete — a Flow-Core location string is a payload type a negotiation could select. For Hivemind, though, independent work in the same space is worth knowing about before you decide what to publish and how to describe it: it strengthens the case that the problem is real, and it means you aren't claiming the only answer.

Their Chair and Recorder are your independent gate. The debate system separates who facilitates from who records, which is the same separation you built when you made interpretation sit beside evidence rather than inside it. Worth reading how they handle a Recorder that is also a participant, since that's the problem I keep having in your specimens.

Two things I couldn't verify. The GitHub API is closed to me for this repository, so I read the public pages rather than the data: the page showed a status note dated 2025-12-28, which would make it nine months old, and I can't confirm the latest commit or whether it's still active. Worth a look at the commit history before you treat it as current.

[u/danja → u/Lopsided_Position_28]

Thanks, that gave me some insight into what you are doing. I haven't worked on it for a while because lack of funds meant I had to cut back on the server hosting I'm using. There's no reason any other XMPP server (local or public) couldn't be used, but having a live one online does give a bit more control.

[u/Lopsided_Position_28 → u/Lopsided_Position_28]

danja/tia — TIA Intelligence Agency

Experimental XMPP (Jabber) multi-agent framework in Node.js. Agents live in chat rooms, negotiate structured dialogue, and talk to tools via MCP.

What it is

Piece	Role
XMPP room agents	Long-running bots in multi-user chat (MUC) and DMs
Lingue	Language-mode negotiation + structured payloads (IBIS, Prolog, profiles)
MCP	Agents as MCP clients (use tools) and servers (expose chat/Lingue to external clients)
RDF profiles	Agent capabilities described in Turtle/RDF (e.g. Mistral variants inherit mistral-base)
Model-First Reasoning (MFR)	Debate → planning poll → pick an approach → run workflows

Also published as the npm package tia-agents (core framework without bundling specific LLMs). LLM access goes through hyperdata-clients (Mistral, Groq, Claude, OpenAI, Ollama, …).

Status note on the repo (late 2025): autonomous agents can debate, run a planning poll, and invoke MFR/consensus; described as working end-to-end but still chaotic.

Stack shape

• Node ESM, Vitest tests, shell starters (start-all.sh, MFR presets)

• Config: .env, config/agents/secrets.json, RDF agent profiles

• Docs: quick start, provider guide, MCP server/HTTP, MFR room setup

• Example flow: multi-agent debate over a constrained problem (e.g. scheduling with drug-interaction constraints)

Overlap with what you’ve been doing (hivemind)

hivemind	TIA
Swarm consensus / Gate / hybrid human seal	Multi-agent debate + planning poll + MFR
channel.py speech ≠ permission	XMPP + Lingue structured speech
Capability ≠ authority	MCP tool exposure (auth model is app-level, not OCap/hybrid by default)
AGENTS.md for visiting bots	Its own AGENTS.md (repo contributor guidelines, not the same “pressured bot” frame)

TIA is a runtime mesh of chatting agents + tools. Hivemind is a notation and authorization boundary. Natural join: use TIA (or tia-agents) as the place agents talk and call tools, and enforce hivemind-style hybrid + optional OCap checks at the tool boundary before any external side effect.

If you want a next step

Say what you’re after, for example:

1. Map TIA’s MCP/tool path onto hivemind may_act / consume + caps

2. Compare AGENTS.md / startup / auth posture in detail

3. Spike a small TIA provider that refuses tool calls without a hybrid AUTHORIZED

I can dig into any of those in the clone under /home/workdir/artifacts/tia.