jarviscore-framework 2.2.0

Describe an agent in a few lines of Python. It reads the web, runs code, works a browser,
remembers what it was told, and picks up where it left off after kill -9.

_{Three agents on one mesh, live in the JarvisCore Desk: 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 (MP4). The Desk ships with JarvisCore Agents, opening soon; the 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]},
])

JarvisCore is a Python runtime for agents that do work, not just talk. You give an agent a role and a prompt; the runtime gives it tools, a loop that checks itself, memory, credentials and durable state, and hands you back an answer you can verify.

• Agents act. Every turn is one real tool call: search and read the web, run Python in a sandbox, drive a browser, draft and deliver.
• Answers come with their evidence. You get the answer, the data behind it, what each tool actually saw, and an honest status: an agent that could not finish says so, and why.
• Work survives. Finished steps survive a crash, agents remember across runs, credentials never enter a prompt, and a person approves anything irreversible.

What people build with it

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

How it works

An agent's work is a loop around the model, and everything outside the model is the runtime's job, not the prompt's:

1. Context in. The system prompt, the agent's own working notes (never dropped, even when the context is full) and facts recalled from earlier runs.
2. Act. One real tool call per turn, in the role the task needs: researcher, coder, browser or communicator. Credentials are placed at the call by Nexus, and only for agents that declare requires_auth = True.
3. Record. Every call and its result are kept, so the answer can cite them and you can check them.
4. Approve. An action marked irreversible waits for a person, then runs once.
5. Done, or not. The agent finishes with complete=True, or says what stopped it.

Agents find each other on the mesh by capability, one agent can run as a pool of workers, and every workflow step is saved in Redis as it finishes.

Start in two minutes

pip install jarviscore-framework

Add one model key to .env (AZURE_API_KEY, CLAUDE_API_KEY, GEMINI_API_KEY or LLM_ENDPOINT), check it with jarviscore check --validate-llm, and run:

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())

No database, no broker, no Docker. Add what you need as you go:

Prefer to write the logic yourself? A CustomAgent is plain Python in execute_task(), on the same mesh as everything else.

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.