JarvisCore
Prescott Data · Coding · Productivity · Other
JarvisCore is an open source Python runtime where AI agents work as equal peers on an agent mesh, claim tasks from a shared ledger, and reach external services through a zero-trust broker.
About JarvisCore
What Is JarvisCore
JarvisCore is a multi-agent framework for teams that run Python AI agents in production. Instead of appointing one orchestrator to plan every step and hold all the state, it puts agents on a mesh where each peer advertises what it can do and takes work from a shared ledger. That single design choice changes what happens when a process dies: another peer picks up the unfinished step, and the goal keeps moving.
The runtime ships two agent profiles. An AutoAgent reasons through a task, writes code, runs it in a sandbox, and repairs its own failures. A CustomAgent runs the Python you write inside execute_task, while keeping the same identity, memory, and messaging as the autonomous profile. Both can sit on one mesh, so a deterministic API worker and a reasoning agent can cooperate without a second framework.
Credentials are handled by Nexus, a broker that injects a token at the moment of an external call. Agents declare which services they need. They never see the key, and it does not appear in prompts, generated code, or traces. The company behind the project is Prescott Data, and the framework is licensed under Apache 2.0.
The limits are worth knowing before you start. JarvisCore is a developer library, not a no-code builder, and the documentation assumes you can read Python and configure environment variables. Durable workflows, crash recovery, and multi-machine discovery need Redis and, for several nodes, the P2P extra. Version 3.0 also adds a control layer that records every effect, but its default report mode observes rather than blocks.
Getting Started
- Install Python 3.10 or later, then run
pip install jarviscore-frameworkandjarviscore initin a new folder. - Copy
.env.exampleto.envand add one model key from Anthropic, Google Gemini, Azure OpenAI, or a local endpoint. - Run
jarviscore check --validate-llmto confirm the package and the provider connection. - Write an agent class with a role, capabilities, and a system prompt, add it to a
Mesh, and callmesh.run_task(). - Add extras as the work demands:
[redis]for durable workflows,[browser]for Playwright automation,[p2p]for agents spread across machines.
Product Information
A quick look at JarvisCore's pricing, supported platforms, and performance.
Best for
The users, tasks, and scenarios where this tool fits best.
Users
- Backend and platform engineers
- Teams running long jobs across several processes
- Companies with strict credential rules
Tasks
- Multi-step research and reporting
- Workflows that must survive a restart
- Browser work on real sites
- Actions that need human approval
Scenarios
- A nightly pipeline that enriches records from three internal systems, where one failed batch should not restart the whole run.
- A support team that wants an agent to propose file changes in a Slack room while people accept them under their own accounts.
- A proof of concept that has to become a production service without a rewrite, because the same agents can run in one process or across several nodes.
Key features
Peer Mesh Without a Central Orchestrator
Agents announce their capabilities over SWIM gossip and find each other by what they can do. When one process stops, another claims its step from the shared ledger and continues the goal. There is no manager agent whose failure takes the whole system down, which is the usual weak point in orchestrator-based designs.
Durable Goals on a Shared Ledger
Mesh.execute_goal() stores the source goal and an obligation ledger in Redis, compiles a capability-addressed DAG under a temporary planning lease, and lets eligible peers claim ready steps atomically. The planning peer loses routing authority once the plan exists, which is what makes durable agent workflows survive a restart without a manager process. Attempts stay immutable, and reconciliation adds work only for obligations that are still unresolved.
Two Agent Profiles on One Runtime
AutoAgent owns the reasoning loop, tool discovery, sandboxed code execution, and repair. CustomAgent exposes deterministic handlers that you write in plain Python. Both share identity, memory, messaging, and storage, so you can move an agent from one profile to the other without rebuilding the surrounding system.
Zero-Trust Credentials Through Nexus
Nexus resolves a provider credential at the execution boundary and places it in the outgoing request. Agents that declare requires_auth get the call, and the token never enters the model context, the code it writes, or the trace log. OAuth2 setup runs locally with jarviscore nexus init and jarviscore nexus register.
Memory That Outlives the Process
Facts an agent chooses to keep are written under .jarviscore/memory/ and recalled in later runs, keyed to its role and separated per tenant with memory_scope_field. Point the runtime at Athena for semantic memory shared across machines. Working, episodic, and long-term memory are handled by the same interface.
Control, Evidence, and Replay
Version 3.0 decides on every provider call, sandboxed program, browser request, and file change before it happens, then writes the decision into a hash-linked journal. jarviscore verify checks that journal offline, jarviscore evidence lists what an agent did for a person or tenant, and jarviscore replay re-runs a recorded session against its own record without calling anything live.
Pros and cons
Pros
- No central orchestrator means a crashed worker does not stall the goal, because peers claim the remaining steps from the ledger.
- Credentials stay outside the model, which removes the usual reason security teams reject agent pilots.
- AutoAgent and CustomAgent share one runtime, so deterministic workers and reasoning agents can be mixed in the same system.
- The 3.0 control layer produces a verifiable journal and offline replay, useful when someone asks what an agent actually did.
- Apache 2.0 licensing allows commercial products with no revenue or user threshold, and installation is one pip command plus a model key.
Cons
- You need Python experience. There is no visual builder, and the setup steps involve environment files and CLI commands.
- Durable workflows and multi-node discovery require Redis and the P2P extra, which adds operational work that a single-process demo hides.
- Traces are debugging records, not audit logs: prompts are previews, tool results are cut at 2,000 characters, and entries expire after seven days.
- Delegated access controls, the Maven cost system, and self-improving workflow DAGs are commercial modules with pricing quoted per engagement.
Frequently asked questions
JarvisCore is an open source agent framework for building and running Python AI agents. Agents join a mesh, discover peers by capability, claim work from a shared ledger, and call external services through a credential broker. The project is maintained by Prescott Data.
Related content
Explore related tools, skills, and articles for JarvisCore.
JarvisCore Alternatives
Base Code
Base44 (Wix) · Coding · ProductivityBase Code is a shared cloud development environment from Base44. Teammates describe changes to an existing GitHub codebase in chat, preview them live and send them back as pull requests.
Google EmbeddingGemma 2
Google DeepMind · Writing · Image · CodingGoogle EmbeddingGemma 2 is a 740M-parameter open model that turns text, code, images, audio, and video frames into vectors in one 768-dimension space, running on phones and laptops.
GitGlow
GitGlow · Coding · ProductivityGitGlow is a local-first desktop Git client that lets independent developers review their own code and their AI agents' changes in one place before shipping.