Home / Agents / JADE

Autonomous agents,
with a permanent record.

A multi-agent platform where software agents negotiate, delegate and subscribe to one another using the international FIPA standard — and every message they exchange is stored as data, in the same tamper-evident ledger as your records.

Pure C No JVM No message broker Starts in under a second
Interactive · watch a negotiation

Put the work out to tender,
and keep the transcript

Four standard conversation patterns, each one a negotiation the platform drives to completion and records end to end. Pick one and run it.

JADE · conversation transcript
fipa-contract-net · real negotiation
Stored as data
Agent frameworks normally keep their conversations in memory or in a message queue, so the reasoning behind an automated decision evaporates the moment the process restarts. Here the negotiation IS data.
📜

Conversations are records, not logs

Every message, every conversation and every agent lifecycle change is written into the database as an ordinary row — queryable, joinable, and auditable months later.

you can ask WHY an agent did something
📐

It speaks the actual standard

All 22 FIPA performatives, and the four interaction protocols that matter in practice — request, query, contract-net and subscribe — implemented against the specification, not approximated.

7 of 7 message round-trip fixtures pass
🪶

No platform to operate

One small native process next to the database. No JVM to tune, no broker to cluster, no container platform underneath it.

the agent platform is a sidecar, not a deployment
What the agents actually do

Four standard
conversation patterns

Ask one agent to act

One agent requests work of another. The responder agrees or refuses, then reports success or failure — each step recorded.

fipa-request

Ask one agent what it knows

A question put to whichever agent holds the answer, returned as an assertion the asker can act on or store.

fipa-query

Put the work out to tender

A call for proposals goes out, bidders answer, the best bid is accepted and the rest are formally rejected.

fipa-contract-net — real negotiation

Tell me when it changes

An agent subscribes to a topic and is informed on every change until it cancels — the standing-instruction pattern.

fipa-subscribe
Where the agents live

The platform holds
no private state

Everything it knows is in the database, which is why nothing is lost when it restarts.

📇

Directory of agents

Who exists, what each one offers, and its lifecycle state — so agents can find each other by capability.

🧵

Conversations

Each negotiation as one thread, with its protocol, participants and how it ended.

✉️

Every message

Sender, receiver, performative, content and the conversation it belongs to.

⛓️

The ledger

Append-only and tamper-evident. An agent's history cannot be quietly rewritten.

You can query which agent won a tender and what it bid, join that to the records it acted on, and ask the same questions of it that you ask of anything else in the business.

Automation you can audit after the fact — not a black box that already ran.

Measured, not claimed

Read from the running platform on live data.

0
FIPA performatives implemented
0
interaction protocols, all exercised in practice
0
messages across 35 conversations, retained
7/7
codec round-trip fixtures passing
0
Java, brokers or containers required
Where JADE sits

The negotiation layer

Its sibling FIPA adds the full agent-platform services — message transport, envelopes and a task ledger — and MESA turns populations of agents into simulations you can run and replay.

The platform layer → The population layer →