jarviscore-framework 2.3.1

pip install jarviscore-framework

JarvisCore is a runtime where AI agents operate as a fleet of equal peers. Agents discover one another by capability, execute tasks from a shared ledger, and authenticate to every external service through a zero-trust broker, never with their own keys.

Most agent frameworks put one orchestrator in charge: it plans, routes every request and holds the state, so the system is only as available as that one process. On a JarvisCore mesh, every agent is a peer. Peers find each other by what they can do (SWIM gossip), take steps from a shared ledger (Redis) and record what they did there, so when one stops, another claims its step and the work goes on. None of them holds a credential: the Nexus broker places it at the call.

Video overview

_{The whole idea in two minutes: discovery by capability, the shared ledger, and the zero-trust broker, on a real mesh.}

Contents

• Video overview
• Components
• Start in two minutes
• What people build with it
• What you can count on
• Go further
• Community
• License

Components

JarvisCore puts eight components around the model: AutoAgent, CustomAgent, the Kernel, the mesh, memory, Nexus, integrations, and people in the loop, with rooms for teams. You write the agents; the rest handles context, tools, credentials, durable state, coordination and approvals around every call the model makes.

Start in two minutes

Use Python 3.10 or later and one model key. In a new folder:

pip install jarviscore-framework
jarviscore init
cp .env.example .env    # add AZURE_API_KEY, CLAUDE_API_KEY, GEMINI_API_KEY or LLM_ENDPOINT
jarviscore check --validate-llm

Then run your first agent. It needs no database, broker or Docker:

import asyncio
from jarviscore import AutoAgent, Mesh


class Researcher(AutoAgent):
    role = "researcher"
    capabilities = ["research"]
    system_prompt = "You find primary sources, read them, and cite every fact."


async def main():
    mesh = Mesh()
    mesh.add(Researcher)
    await mesh.start()
    result = await mesh.run_task(
        agent="researcher",
        task="What changed in the EU AI Act's final text for open-source models?",
    )
    print(result["result_summary"])  # the answer
    print(result["evidence"])        # what the tools actually saw
    await mesh.stop()

asyncio.run(main())

Add capabilities as you need them: a browser ([browser]), durable workflows and crash recovery ([redis] with REDIS_URL), agents on several machines ([p2p]), or everything ([full]). Prefer plain Python? A CustomAgent runs on the same mesh. See Getting Started for the full walkthrough.

What people build with it

A research team, live in the Desk

_{Three agents on one mesh: a scout reads official docs on the live web, an analyst compares, a writer delivers the brief with its sources. A real run, idle time trimmed. Play the video to pause and scrub. The Desk ships with JarvisCore Agents, opening soon.}

The whole team is 30 lines of Python:

class Scout(AutoAgent):
    role = "scout"
    capabilities = ["web_research"]
    default_kernel_role = "researcher"
    system_prompt = "You find primary sources on the live web, read them, and cite every fact."

class Analyst(AutoAgent):
    role = "analyst"
    capabilities = ["analysis"]
    default_kernel_role = "communicator"
    system_prompt = "You compare options strictly on the evidence."

class Writer(AutoAgent):
    role = "writer"
    capabilities = ["writing"]
    default_kernel_role = "communicator"
    system_prompt = "You write short, decisive briefs for engineering leads, citing sources."

results = await mesh.workflow("vector-db-brief", [
    {"agent": "scout",   "task": "Gather the facts this request turns on, from official docs: ..."},
    {"agent": "analyst", "task": "Compare the options on the scout's evidence.", "depends_on": [0]},
    {"agent": "writer",  "task": "Write a decision brief of at most eight lines.", "depends_on": [1]},
])

Read a whole website

One goal_oriented agent opens the catalogue, walks every page, computes the figures with code and saves a report: 32 books, 2 pages, every figure correct. browse_a_whole_site.py · real time 1m 56s · needs jarviscore-framework[browser] and BROWSER_ENABLED=true.

Watch it run in a terminal

Compute, never estimate

Revenue and quarter-on-quarter growth for four regions from a 400-row CSV, computed by code the agent writes and runs in a sandbox. Every figure matches a hand-written check. analyst_that_computes.py · real time 54s.

Watch it run in a terminal

Remember across runs

Tell it once. A new process, given nothing, still knows. Kept facts live in .jarviscore/memory/, with nothing to install; point it at Athena for semantic memory shared across machines. agent_that_remembers.py.

Watch it run in a terminal

Survive kill -9

Kill the process mid-workflow and run the same command again: finished steps come back from Redis, and only the unfinished work runs. survives_a_crash.py · needs REDIS_URL.

Watch it run in a terminal

Work as a team, in Slack _{new in 2.3}

People ask in their own words, agents change the team's shared files, and every change comes back as a proposal people accept with one tap, as themselves. Work that used someone's own Gmail or CRM is held for them. Live against a Slack sandbox with a real model: a draft, a revision from a teammate's feedback, an acceptance only the person who decided could confirm, and work that finished once after a restart. Build a multiplayer agent.

What you can count on

Go further

Community

Every other week we debug real agents live in office hours on Discord. If JarvisCore saves you time, a ⭐ helps other developers find it.

License

Apache 2.0. See LICENSE. You can build and sell products with it; there is no revenue or user threshold that requires a commercial agreement. Separately licensed enterprise modules have their own terms; see JarvisCore Enterprise.

Building with JarvisCore? An optional Built with JarvisCore credit on your About page or docs is appreciated; the trademark policy applies.