Customer support swarm (P2P + Nexus auth)

September 19, 2026 · View on GitHub

The production runtime for multi-agent systems — a peer-to-peer mesh with no central orchestrator, zero-trust credentials, durable state that survives kill -9, and a built-in catalog of typed integration atoms. Observability included, not upsold.

pip install jarviscore-framework

4 agents in 4 separate processes discover each other over SWIM gossip, claim research steps from a shared ledger, research the live web, and deliver the synthesized brief to Slack through the encrypted credential vault

_{4 agents, 4 separate processes, no MCP, no orchestrator. They discover each other over SWIM gossip, claim steps from a shared ledger,

research the live web, and deliver the brief to Slack — the token never visible to agent code, resolved by the encrypted vault at the call boundary.

Real run, time compressed — full 4-minute narrated video · reproduce it with examples/demo_synthesizer.py + demo_node_1/2/3.py}

$7-agent investment committee evaluates a \$1.5M position; the process is kill -9'd mid-deliberation, rerun with the same workflow id, and finishes without re-running the four analysts$

_{A 7-agent committee deliberates a \$1.5M position on live market data. We kill -9 it mid-deliberation.

Rerun with the same workflow id: the four analyst results come back from Redis — not re-run, not re-billed — and the committee finishes the job.

Real output, time compressed — reproduce it with examples/investment_committee (kill_watcher.py stages the crash)}

Why developers switch

Six things you get here that you will not assemble from a typical agent framework:

1. Agents never touch credentials. Nexus, a zero-trust credential broker, ships inside the framework. Set requires_auth = True and the runtime injects scoped, encrypted credentials into atoms at call time — no raw keys in prompts, agent context, or .env sprawl. A leaked agent trace leaks no secrets.

2. Tools without MCP plumbing. Built-in typed atoms with auth injected at runtime; inspect your installed catalog with jarviscore atom list. Missing one? Write a Python function, validate it with jarviscore atom test, drop it in the registry — no server to stand up, no wiring. And when no atom exists, AutoAgents write their own sandboxed code with self-repair and keep what worked in a verified-work registry.

3. No central orchestrator to babysit. Agents form a SWIM gossip mesh over ZMQ, discover each other by capability, and claim workflow steps atomically from Redis. Any node can die — another claims its work. There is no coordinator process whose crash takes the fleet down.

4. State outlives the process. You just watched it: kill -9 mid-deliberation, rerun the same workflow id, completed steps return recovered from Redis — not re-run, not re-billed.

5. Observability is not an enterprise upsell. Per-step traces (jarviscore inspect <workflow>), episodic ledgers, and Prometheus + Grafana in the bundled compose file — all in the Apache-2.0 package. No control-plane subscription to see what your agents did.

6. Memory agents share, not just keep. Athena is a structured knowledge graph with heat-based scoring — fleet memory that compounds across agents and sessions, not one agent's private diary.

What is JarvisCore?

JarvisCore is a Python framework for building AI agent systems that can plan, reason, execute code, browse the web, search the internet, and connect to 150 external services out of the box. A single agent runs with three attributes. A fleet scales across machines with peer-to-peer discovery, shared memory, and crash recovery.

Architecture

You write agents. JarvisCore owns the runtime underneath them: identity, memory, retrieval, routing, and recovery.

                       your agents
            AutoAgent  ·  CustomAgent  ·  Workflows
                            │
  ┌─────────────────────────┴──────────────────────────┐
  │                jarviscore-framework                │
  │                                                    │
  │   kernel · planning · P2P mesh · atoms · HITL      │
  │                                                    │
  │   ┌───────────┐   ┌───────────┐   ┌────────────┐   │
  │   │   Nexus   │   │  Athena   │   │ RAG+Search │   │
  │   │ identity  │   │  memory   │   │ retrieval  │   │
  │   └───────────┘   └───────────┘   └────────────┘   │
  │      bundled         backend         built-in      │
  │                                                    │
  │   workflow state · step outputs · traces ⇄ Redis   │
  │   kill the process — state survives, steps resume  │
  └─────────────────────────┬──────────────────────────┘
                            │  called like any library
                            ▼
                     ┌──────────────┐
                     │     Odin     │   graph intelligence
                     │ odin-engine  │   separate package
                     └──────────────┘

Layer	Role	How you reach it
Durable state	Workflow state, step outputs, and traces live in Redis — `kill -9` the process, rerun the same workflow id, completed steps recover instead of re-running.	Automatic when `REDIS_URL` is set
Nexus	Zero-trust identity. Encrypts OAuth tokens and API keys, injects them into atoms at runtime so agents never touch raw credentials.	Ships inside the framework — `jarviscore nexus init`
Athena	Structured knowledge graph with heat-based scoring and cross-agent memory sharing.	Memory backend — `jarviscore memory init`
RAG + Search	Document retrieval and live internet search.	Built in — see Features
Odin	Graph intelligence: ranks high-signal paths in graphs with 10K–5M entities.	Companion library — `pip install odin-engine`

Installation

pip install jarviscore-framework

# With Redis support (required for distributed features)
pip install "jarviscore-framework[redis]"

# With Prometheus metrics
pip install "jarviscore-framework[prometheus]"

# With TypeSafe Jev decision models
pip install "jarviscore-framework[typesafe]"

# Everything
pip install "jarviscore-framework[full]"

Quick Start

# Scaffold a new project with example agents
jarviscore init --examples
cp .env.example .env
# Add one LLM credential to .env: AZURE_API_KEY, CLAUDE_API_KEY,
# GEMINI_API_KEY, or LLM_ENDPOINT.
# Existing Prescott entitlement holders may instead set JARVISCORE_PROMO_TOKEN.

# Start shared infrastructure (Redis, Mongo, Prometheus, Grafana)
docker compose -f docker-compose.infra.yml up -d

# Start Nexus Gateway locally (generates keys and updates .env)
jarviscore nexus init

# Validate installation
jarviscore check --validate-llm

AutoAgent (3 attributes, zero boilerplate)

from jarviscore import Mesh
from jarviscore.profiles import AutoAgent

class CalculatorAgent(AutoAgent):
    role = "calculator"
    capabilities = ["math"]
    system_prompt = "You are a math expert. Store result in 'result'."

mesh = Mesh()
mesh.add(CalculatorAgent)
await mesh.start()

results = await mesh.workflow("calc", [
    {"agent": "calculator", "task": "Calculate factorial of 10"}
])
print(results[0]["output"])  # 3628800

CustomAgent (full control)

from jarviscore import Mesh
from jarviscore.profiles import CustomAgent

class ProcessorAgent(CustomAgent):
    role = "processor"
    capabilities = ["processing"]

    async def execute_task(self, task):
        data = task.get("params", {}).get("data", [])
        return {"status": "success", "output": [x * 2 for x in data]}

mesh = Mesh()
mesh.add(ProcessorAgent)
await mesh.start()

results = await mesh.workflow("demo", [
    {"agent": "processor", "task": "Process", "params": {"data": [1, 2, 3]}}
])
print(results[0]["output"])  # [2, 4, 6]

See it running

Real systems built on JarvisCore, recorded end to end.

Demo	What it shows
ContentForge	Six named agents turn mixed sources into a cited, reviewed draft — Apollo routes on the mesh, Heimdall gates the output
Office Hours	Live sessions where we debug real agents, every other week

Features

Agent Profiles

Profile	You Write	JarvisCore Handles
AutoAgent	`role`, `capabilities`, `system_prompt`	Kernel OODA loop, tool generation, sandboxed execution, self-repair, planning
CustomAgent	`execute_task()` and/or `on_peer_request()`	Mesh routing, discovery, lifecycle, full infrastructure injection

Kernel and Planning

The Kernel runs an Observe-Orient-Decide-Act (OODA) loop for every AutoAgent task. In v1.1.0, the loop is backed by a dedicated Planner, StepEvaluator, and proof-of-work gates that balance cost, reasoning depth, and execution reliability.

Component	Purpose
Planner	Decomposes goals into executable steps using heavy-tier models
StepEvaluator	Classifies step outcomes using nano-tier models for fast, cheap evaluation
GoalContext	Tracks plan state, step history, and convergence signals
EpistemicLedger	Records what the agent knows, assumes, and has verified

TypeSafe Jev Decision Models

JarvisCore supports TypeSafe Jev for bounded Choice, Score, and Noul judgments. Configure TYPESAFE_API_KEY; the Mesh injects one shared async client as self.decisions, and AutoAgents receive an evaluate_decisions thinking tool. Jev complements the generative model used for planning and execution; it does not replace it.

result = await self.decisions.evaluate(
  state={"ticket": "Customers are seeing 500 errors."},
  questions={
    "team": {
      "type": "choice",
      "instructions": "Which team should handle this?",
      "criteria": {
        "support": "Account and product assistance.",
        "engineering": "Defects and service incidents.",
      },
    }
  },
)
print(result.answers["team"])

Set KERNEL_ROUTER_PROVIDER=typesafe to opt into Jev-backed subagent selection. Explicit planner, profile, and execution-contract roles retain precedence. See Decision Models.

Set TASK_COMPLEXITY_PROVIDER=typesafe to select direct Kernel execution and its model tier, or RAG_DECISION_PROVIDER=typesafe to classify the FAISS shortlist into accepted, conflicting, and excluded passages before generation.

Service Integrations

Every integration is a single-file Python function called an atom. Atoms are registered in the seed registry and discovered by agents at runtime. No SDK wiring required.

Browse integration bundles by category

Category	Bundles
CRM and Sales	Salesforce, HubSpot, Zoho CRM, Pipedrive, Dynamics 365, Oracle CX, Attio, Close, Keap, Insightly, Nutshell, Nimble, Streak, Salesflare, Capsule, Agile CRM, Less Annoying CRM, Folk, Apollo and more
Project Management	Jira, Linear, Asana, Monday, Trello, ClickUp, Notion, Airtable, Todoist, Shortcut, Wrike, Workfront, Height, Coda, Podio, Nifty, ProofHub, LiquidPlanner, Freedcamp, Pivotal Tracker, Targetprocess
Communication	Slack, Discord, Telegram, WhatsApp Business, Twilio, Gmail, MS Graph (Teams/Outlook), Google Chat, Webex, Mattermost, Rocket.Chat, Zoom
Developer Tools	GitHub, GitLab, Jenkins, CircleCI, Travis CI, TeamCity, Sourcegraph, Phabricator, Perforce, Confluence, Beanstalk, Assembla, SourceForge, Serper (web search)
Support and Chat	Zendesk Chat, Intercom, Freshchat, Crisp, Drift, Gorgias, LiveChat, Tawk.to, Zoho Desk
Cloud Storage	Google Drive, Google Sheets, Dropbox, Box, Amazon S3, GCS, Azure Blob Storage, Egnyte, Backblaze B2, Dropbox Sign
Finance and Accounting	Stripe, Square, QuickBooks, Xero, FreshBooks, Zoho Books, Wave, Sage Business Cloud, Sage Pastel, NetSuite
African Fintech and Infra	M-Pesa (Safaricom), Paystack, SimplePay, Africa's Talking, Infobip, Jumia Seller Center, Prembly, KRA (Kenya Revenue Authority)
Marketing and Ads	Mailchimp, SendGrid, Klaviyo, Brevo, ActiveCampaign, Google Ads, LinkedIn Ads, Twitter Ads, Reddit Ads, TikTok Ads, Snapchat Ads
Analytics	Google Analytics, Mixpanel, Amplitude, Segment, PostHog, Plausible, Matomo, FullStory, LogRocket, Pendo, Kissmetrics
E-commerce and CMS	Shopify, WooCommerce, WordPress, Wix Stores, PrestaShop, Etsy, Shift4Shop
ERP and HR	SAP, Oracle ERP, Odoo, BambooHR, Zoho People, Zoho Shifts
Social and Content	LinkedIn, Twitter/X, YouTube, Reddit
Ops and Identity	PagerDuty, Okta, Google Calendar, Google Maps, Google People, what3words
Healthcare	OpenMRS

The registry is the source of truth — jarviscore atom list prints every bundle and atom in your installed version.

# List all registered atoms
jarviscore atom list

# Test a custom atom before registration
jarviscore atom test my_atoms/fetch_orders.py

Browser Automation

Agents can launch headless browser sessions for web research, form filling, and scraping. The BrowserSubAgent uses CUA-capable models (Gemini Computer Use, gpt-5.4-mini) or falls back to any multimodal model with vision.

# Set in .env
BROWSER_ENABLED=true
BROWSER_MODEL=gemini-2.5-computer-use

Internet Search

Built-in internet search via Gemini Grounded Search or Serper. Agents call it as a standard tool during task execution.

# Set in .env (pick one)
GEMINI_API_KEY=...         # Gemini Grounded Search (primary)
SERPER_API_KEY=...         # Serper fallback

RAG Pipeline

Chunk documents, generate embeddings, and store them in a local FAISS index. Agents query the index during task execution to ground responses in source material.

Unified Memory

Layer	Purpose
WorkingScratchpad	Short-lived key-value store for the current task
EpisodicLedger	Append-only event log for agent history
LongTermMemory	Persistent Redis-backed storage across sessions
Athena	Structured knowledge graph with heat-based scoring and cross-agent memory sharing

Nexus Credentials

Nexus is the built-in credential manager. It stores OAuth tokens and API keys, encrypts them with a per-deployment secret, and injects them into atoms at runtime. Agents never handle raw credentials.

class MyAgent(CustomAgent):
    requires_auth = True  # Nexus credentials injected automatically

P2P Mesh and Distributed Workflows

Agents discover each other over a SWIM protocol gossip mesh using ZMQ transport. Workflows execute across machines with Redis-backed crash recovery and step claiming. For goals whose steps are not known in advance, Mesh.execute_goal() publishes capability-addressed work without creating a master agent router.

mesh = Mesh(config={
    "p2p_enabled": True,
    "bind_port": 7950,
    "redis_url": "redis://localhost:6379/0",
})

await mesh.start()
result = await mesh.execute_goal(
  "Inspect the active opportunity and prepare a decision brief.",
  workflow_id="opportunity-2026-09-11",
)
print(result["status"], result["obligation_status"], result["response_status"])

Attempts remain immutable across revisions. Reconciliation appends work only for unresolved obligation IDs, while satisfied obligations retain their evidence. See Durable Goal Execution.

Observability

Signal	Backend
Traces	TraceManager writes to Redis and JSONL files
Metrics	Prometheus counters and histograms per step
Logs	Structured JSON logging via `LOG_LEVEL`

Infrastructure Stack

Every agent receives the full infrastructure stack automatically through dependency injection. No manual wiring required.

Feature	Injected as	Enabled by
Blob storage	`self._blob_storage`	`STORAGE_BACKEND=local` (default)
Context distillation	`TruthContext`, `ContextManager`	Automatic
Telemetry and tracing	`TraceManager`	Automatic (`PROMETHEUS_ENABLED` for metrics)
Mailbox messaging	`self.mailbox`	`REDIS_URL`
Function registry	`self.code_registry`	Automatic (AutoAgent)
Kernel OODA loop	`Kernel`	Automatic (AutoAgent)
Distributed workflow	`WorkflowEngine`	`REDIS_URL`
Nexus credentials	`self._auth_manager`	`requires_auth=True` + `NEXUS_GATEWAY_URL`
Unified memory	`UnifiedMemory`, `EpisodicLedger`, `LTM`	`REDIS_URL`
TypeSafe decisions	`self.decisions`, `evaluate_decisions` tool	`TYPESAFE_API_KEY` + `typesafe` extra

CLI Reference

jarviscore init              # Scaffold a new project (.env.example + optional examples)
jarviscore check             # Validate environment and provider connectivity
jarviscore check --validate-llm  # Also test LLM round-trip
jarviscore check --validate-typesafe  # Test one Jev decision round-trip
jarviscore smoketest         # Quick end-to-end smoke test
jarviscore atom list         # List all registered integration atoms
jarviscore atom test         # Validate atom structure or live Nexus connection
jarviscore nexus init        # Generate keys and start Nexus Gateway via Docker
jarviscore nexus status      # Check Nexus Gateway health
jarviscore nexus register    # Register an OAuth provider (e.g. github, slack)
jarviscore nexus list        # List registered providers
jarviscore nexus test        # Open browser OAuth flow for a provider
jarviscore memory init       # Initialize Athena MemOS backend
jarviscore memory status     # Check Athena health
jarviscore memory search     # Query the knowledge graph

Framework Integrations

JarvisCore is async-first. It integrates directly with async web frameworks.

Framework	Integration
FastAPI	`JarvisLifespan` via `jarviscore.integrations.fastapi` (3 lines)
aiohttp, Quart, Tornado	Manual lifecycle (see docs)
Flask, Django	Background thread pattern (see docs)

from fastapi import FastAPI
from jarviscore.profiles import CustomAgent
from jarviscore.integrations.fastapi import JarvisLifespan

class ProcessorAgent(CustomAgent):
    role = "processor"
    capabilities = ["processing"]

    async def on_peer_request(self, msg):
        return {"result": msg.data.get("task", "").upper()}

app = FastAPI(lifespan=JarvisLifespan(ProcessorAgent()))

Production Deployment

For production, set these environment variables instead of relying on development defaults:

NEXUS_SECRET=<long-random-string>       # Do not rely on machine-UUID fallback
NEXUS_GATEWAY_URL=https://nexus.yours   # Point to your deployed Nexus Gateway
REDIS_URL=redis://<persistent-host>     # External Redis with persistence enabled
STORAGE_BACKEND=azure                   # Or mount a persistent volume for local mode
SANDBOX_MODE=remote                     # Isolate code execution from the host
LOG_LEVEL=INFO                          # Avoid token content in logs

See the Production Deployment Guide for the full checklist, fleet scaling, and kernel tuning.

The Prescott OSS ecosystem

JarvisCore is the runtime. These build on it or plug into it.

Project	What it does	License
jarviscore-framework	The agent runtime — planning, memory, mesh, atoms	Apache 2.0
Odin-1	Graph intelligence for agents navigating knowledge graphs	MIT

Nexus and Athena ship inside this repository — see Architecture.

If you build multi-agent systems, star the repo ⭐ to support open-source agent infrastructure.

Documentation

https://jarviscore.developers.prescottdata.io/

Section	Description
Getting Started	Install, scaffold, and run your first agent in 5 minutes
Concepts	Architecture, model routing, planning, memory, Nexus
Guides	AutoAgent, CustomAgent, workflows, HITL, browser, testing, production
Integrations	Built-in service bundles with usage examples
Reference	Agent API, CLI, configuration, and troubleshooting
Changelog	Full release history

Examples

The Jev decision demo needs only a TypeSafe key. Distributed examples require Redis (docker compose -f docker-compose.infra.yml up -d).

# Native Choice, Score, and Noul decisions (no Redis or LLM key)
TYPESAFE_API_KEY=... python examples/typesafe_jev_decisions.py

# Financial pipeline (single process, AutoAgent)
python examples/financial_pipeline.py

# 4-node distributed research network
python examples/research_synthesizer.py &
python examples/research_node_1.py &
python examples/research_node_2.py &
python examples/research_node_3.py &

# Customer support swarm (P2P + Nexus auth)
python examples/support_swarm.py

# Investment Committee: 7-agent workflow with web dashboard
cd examples/investment_committee
python committee.py --mode full --ticker NVDA --amount 1500000

Version

1.12.0

License

Apache 2.0. See LICENSE for details.

You can build and sell products using the Apache-licensed framework. There is no revenue or user-count threshold that requires a commercial agreement simply because your product grows. Separately licensed enterprise modules and services have their own terms; see JarvisCore Enterprise.

Built with JarvisCore

Building something with JarvisCore? Help others discover the framework by adding Built with JarvisCore to your product's About page, footer, or documentation.

[Built with JarvisCore](https://developers.prescottdata.io)

This product credit is optional and appreciated. It does not replace the copyright, license, and applicable attribution notices required by Apache 2.0. Use it as a factual acknowledgment, not an implication of endorsement; the trademark policy applies.