Agent swarms that share one brain.
Most swarm frameworks treat memory as a side effect. Agents pass messages, state lives in RAM, and context is gone the moment a run ends. Purple8 makes the knowledge graph the shared memory: every agent reads and writes the same persistent store, so Agent B sees what Agent A found the moment it lands. No handoff code. No message routing. The graph is the coordination layer.
What Purple8 gives every agent in the swarm
Six primitives. Zero glue code.
Shared persistent memory
All agents read and write the same graph engine. Agent B's discovery is visible to Agent C the moment it's written — no message passing, no explicit handoff code.
CDC event coordination
graph.poll_changes and graph.wait_for_changes let agents subscribe to graph mutations. Agent B reacts to Agent A's writes without either agent knowing about the other.
Per-agent RBAC
Each agent has its own API key and role. Researcher: editor. Reviewer: viewer. Coordinator: admin. Enforced at the engine level — not in application code.
Shared vector + graph search
Any agent can run GraphRAG over the entire swarm's accumulated knowledge. Agent 4 can semantically search everything Agents 1–3 have written.
Workflow coordination
Journey Engine gives the coordinator agent a state machine: advance stages, enforce SLAs, require human approval before the swarm's output is finalised.
Full provenance audit trail
Every node and edge carries agent identity and timestamp. You can trace any finding back to the source document and the agent that extracted it.
Swarm patterns
What teams are building
Research synthesis swarm
Agent pipeline
- Ingestion agent → DocIntel → graph
- Extraction agent → entities + relationships
- Analysis agent → cross-document patterns via GraphRAG
- Writer agent → synthesis report from graph context
“Agent 4 sees Agent 1's work the moment it lands — no handoff code.”
M&A due diligence swarm
Agent pipeline
- Legal agent → contract graph
- Financial agent → revenue + risk graph
- Technical agent → architecture + codebase graph
- Coordinator → traverses all three, flags conflicts
- Partner → HITL gate before final memo
“All agents share one graph. Coordinator queries across all domains in one traversal.”
Threat hunting swarm
Agent pipeline
- N scanner agents (parallel) → each scans a segment
- Correlation agent → detects cross-segment patterns
- SOC agent → elevates threats, triggers containment
- Analyst → HITL gate on containment decisions
“Scanner agents write findings concurrently. Correlation agent reacts via CDC — no polling.”
AEC project review swarm
Agent pipeline
- BIM ingestion agent → building graph
- Structural agent → rigidity + load analysis
- MEP agent → max-flow + energy balance
- Compliance agent → code violation detection
- PM agent → rolls up findings, triggers approval workflow
“Each specialist agent writes findings as typed edges. PM queries all in one traversal.”
Competitive intelligence swarm
Agent pipeline
- Web agents → scrape + push to DocIntel
- Extraction agent → pricing, features, positioning graph
- Trends agent → temporal PageRank on feature mentions
- Strategy agent → RAG over the graph, produces briefing
“Temporal PageRank shows which competitor moves are gaining momentum over time.”
Compliance audit swarm
Agent pipeline
- Document ingestion agent → policies, contracts, logs
- Extraction agent → obligations + deadlines graph
- Monitoring agent → checks compliance state continuously
- Escalation agent → triggers HITL on breaches
- Auditor → immutable trail of every finding
“The audit trail IS the graph — regulators can query it directly.”
FAQ
Common questions
What is the main problem with multi-agent systems today?
Most multi-agent frameworks (AutoGen, CrewAI, LangGraph) treat memory as a side effect — agents pass messages and state lives in RAM, lost between runs and invisible to other agents. This means Agent B cannot see what Agent A discovered unless you explicitly code the handoff. Purple8 solves this by making the knowledge graph the shared memory: every agent reads and writes the same persistent store, so every discovery is immediately available to the swarm.
How does Purple8 coordinate agents without message passing?
Via the CDC (Change Data Capture) event bus. When any agent writes a node or edge to the graph, all subscribers receive the event immediately. Agent B can subscribe to 'new FINDING nodes written by Agent A' and react without polling, without a message queue, and without Agent A knowing Agent B exists. This makes swarm coordination emergent rather than explicitly programmed.
How is access controlled across agents in a swarm?
Each agent authenticates with its own API key and is assigned a role (viewer/editor/admin/super_admin). RBAC is enforced per MCP tool call — a researcher agent can add nodes and edges but cannot delete them; a reviewer agent can read but not write. This is enforced at the graph engine level, not in application code, so it cannot be bypassed.
Can I audit what each agent did in a swarm run?
Yes. Every node and edge written to Purple8 carries the agent identity, timestamp, and operation type. The graph is the audit trail — you can query 'show me every node written by Agent A in the last 24 hours' or traverse the provenance chain from any finding back to the source document and the agent that extracted it.
Build your first swarm in 60 seconds
Free to start. Shared graph memory, CDC coordination, and per-agent RBAC work from day one.