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.
Watch the JarvisCore Agents launch film
pip install jarviscore-framework
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
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)
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.
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.
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 |
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]"# 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-llmfrom 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"]) # 3628800from 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]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 |
| 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 |
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 |
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.
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.pyAgents 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-useBuilt-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 fallbackChunk documents, generate embeddings, and store them in a local FAISS index. Agents query the index during task execution to ground responses in source material.
| 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 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 automaticallyAgents 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.
| Signal | Backend |
|---|---|
| Traces | TraceManager writes to Redis and JSONL files |
| Metrics | Prometheus counters and histograms per step |
| Logs | Structured JSON logging via LOG_LEVEL |
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 |
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 graphJarvisCore 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()))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 logsSee the Production Deployment Guide for the full checklist, fleet scaling, and kernel tuning.
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.
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 |
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 15000001.14.1
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.
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.