Changelog¶
All notable changes to JarvisCore Framework are documented here. This project follows Semantic Versioning.
Versioning Policy (effective v1.1.0)
Releases prior to v1.1.0 did not follow SemVer consistently: new features were shipped in patch releases and a breaking change landed in v0.3.1 (a patch). Starting with v1.1.0, this project adheres to strict SemVer:
- PATCH (1.1.x): backward-compatible bug fixes only.
- MINOR (1.x.0): new features, new public API surface, backward-compatible behavioral changes.
- MAJOR (x.0.0): breaking changes to the public API.
The public API is what jarviscore exports in __all__, the settings
in the configuration reference, and the
behaviour the guides document. Kernel internals, prompts and private
(_-prefixed) names are not covered and may change in any release.
Public API is deprecated with a warning in a minor release before it is
removed, and removals are batched into planned major releases.
Versions 1.0.3 and 1.0.4 contain critical regressions and should be
avoided. They will be yanked from PyPI. Pin jarviscore-framework>=1.1.0.
3.0.1 2026-10-27¶
Needs Nexus 0.7.1 or later for your own systems (api_base_url); the bundled compose file uses it.
Fixed¶
-
Room work plans in a third of the time. The room's rules for taking work back are now a planning brief instead of part of the request, so they no longer become obligations every plan had to repair. The planner is told that work done for a person runs with their own accounts, so plans no longer add steps to find that account, and the plan audit no longer rejects them for it. In our live runs a one-step request in a room went from 30–160 s of planning (5–8 model calls) to about 10 s (3 calls).
-
Action approvals in rooms. An integration action that needs approval now appears in the room's thread with Approve and Decline, held to the approval rules and scopes. Before, the step waited with nothing to approve. Surfaces can override
ChatSurface.show_approval; the default posts a message. See Chat Surfaces. - Rooms ask for a missing account. When room work needs a system the person who asked has not connected, that person is asked privately to connect it (
ChatSurface.show_connect, a Nexus consent link), and the work goes on once they have. Before, the step waited with no one told. - Room work in connected systems. Asking a room's agents to act in a system (approve a claim, send a message) no longer has to produce a file to be planned.
- A person's evidence includes what was refused before anyone was asked.
jarviscore evidenceandpeople.accountnow list an action the policy refused when it was previewed (a payment to an account not on record, say), marked as previewed, and count it as refused. - A room says where finished work was done. Work done in a connected system reads "the agents finished (completed) in Claims Hub", not "with no changes to the files"; the
ask.finishedevent lists itssystems. - A policy refusal says it was the policy.
PolicyDeniedand a missing-scope refusal now read "Your organisation's policy refused this call, so nothing was sent: …" and name the system that never received it, so agents stop reporting a refusal as the provider's. - Work results reach people without runtime receipt ids, including ones written in Markdown.
- A room says why work did not finish. The result of failed work now carries its reason (still shown only to its asker when it used their private access).
- No agent waits on a room's agent. Other agents could ask a room's agent directly (
ask_capability); it never answers peer requests, so the asker waited out the whole timeout (5 minutes). It is no longer offered as a peer, as it already was not for planning. - The room agent starts work only in the room. It no longer has the peer tools (
ask_peer,ask_capability), which did work out of the room's sight and held the turn until the peer answered. - Your own systems through Nexus. A provider registered in Nexus with an
api_base_url(an in-house claims or ERP system) can now be called on that host. Before, only hosts in the shipped catalogue were accepted, so its credential was refused everywhere. - Replay asks the model exactly what the run asked. A replay now starts where the run's loop started (a resumed run from its checkpoint, after the approved action), offers the tools the run was offered, and keeps a gate's own model calls (the effect reviewer's) with the gate. Before, a run that waited for an approval, or ran with memory or a coder's integrations, replayed its decisions but asked the model differently, and a gate's model answer could be handed to the agent. In our live claims runs, model requests identical to the record went from none to all (14 of 14).
- The model no longer sees runtime plumbing.
_nexus_connection_id,_nexus_provider,_resumeand_new_execution_epochare left out of the agent's input context; code reads them as before. - Clearer evidence output.
jarviscore verifysays "(1 refused before approval)" rather than "(0 refused, 1 refused before approval)";jarviscore evidencenames the effect and integration of a call refused for a missing scope, and showsagent=-for room runs. A step paused for a person is logged as paused, not as an error. - Rooms name people, not their keys. Results and replies say "Erin Walsh does not hold claims.approve", not "acme/erin", and drop receipt ids cited without their
tool:prefix. - A missing model provider says what to set. With none configured, a call fails with "No LLM provider is configured…" and the settings to add, instead of "All LLM providers failed. Last error: None".
3.0.0 2026-10-26¶
Added¶
- Control before every effect. Every provider call, sandboxed program, host
command, artifact, workspace change, memory, peer message, step result and
browser request is decided on before it happens and recorded.
CONTROL_MODE=report(the default) records;strictrefuses what policy does not allow, and anything whose decision cannot be recorded. A control policy file (CONTROL_POLICY_PATH) adds deployment rules, approval rules, grounding and scopes.jarviscore policy check | review | scopesvalidates a policy, lists what strict mode would refuse, and shows who may do what. See Turning On Control. - Integrations are held to what their code sends. Each integration's operations are read from its source (914 of 1,186 shipped ones fully verified), and code the model writes may only mutate a provider through operations its own code verifiably sends.
- Approvals the institution decides.
approvals:rules set which actions need a person, which roles may approve, maker-checker, and how strongly the approver must be identified (sign_assertionfor approvals signed by your backend). An approved action runs at most once; one interrupted mid-run is leftOUTCOME_UNKNOWNfor a person to reconcile. Payments to Stripe, Adyen, Mollie, GoCardless, Checkout.com and PayPal carry an idempotency key. - Grounding.
grounding:rules require a payment's account and amount (or any field) to come from records the runtime itself read, so an instruction planted in a document cannot redirect it. Live red team, strict mode: 0 of 14 attacks succeeded. See Grounding. - Agents that act for your users.
on_behalf_of=OnBehalfOf.of(tenant, user)onrun_task,execute_goal,submit_goal,workflowandcreate_chat_router: the work uses that user's own credentials (Nexus 0.7 releases a credential only to work for its owner, never falling back to another), within what they delegated (a mandate), on any node, and every record names them.mesh.connectstarts a user's consent. See Agents That Act for Your Users. - Your organisation's scopes. A
scopes:section says which operations need which scope (approve claims, read financial reports, file a SAR), with limits checked on the outgoing request; your application says what each person holds. A request beyond them is refused, in report mode too, and the agent is told what is out of reach.approved_byrequires an approver holding a scope within its limit. See the guide. - A verifiable journal. Decisions and effects are written as hash-linked
events;
jarviscore verifychecks a journal (or a copy) offline.jarviscore evidence acme/u_1lists what agents did for a person or tenant,--exporthands it to their auditor (verify --export), and--eraseremoves a person's replay content while the journal still verifies. Records hold methods, hosts, paths and decisions, never bodies or credentials. - Replay.
jarviscore replayre-runs a recorded agent run from its record, every model call and tool answered from it, so nothing is called and nothing acts, and reports whether the agent made the same decisions.JOURNAL_CAPTUREandJOURNAL_CONTENT_DAYS(30) control what is kept. See Replay. claims/: each control and evidence claim with its scope, assumptions and the tests behind it; a claim citing a missing test fails the build.
Changed¶
- Report mode refuses what a person may not do. Requests beyond a person's
scopes or mandate are refused whatever the mode (except
off); everything else is still only recorded in report mode. - Faster startup and calls.
import jarviscoretakes about 0.13 s instead of 3 s, and each sandboxed run starts about 3 s sooner (a live coder step: median 8.9 s to 7.45 s). Provider calls reuse their connection (NEXUS_KEEPALIVE_SECONDS): about 500 ms to 90 ms per call on HTTPS. - Square integrations use a stable idempotency key, so a retried payment is not a new payment.
Fixed¶
- Agents report what their actions did. An answer written after the budget ran out, or after an approval, now rests on the run's record: a browser action's result says what the form submitted and exactly what left the browser, and an approval shows the values a form will submit.
- Repairing an integration that acts on the world no longer performs it
(
ATOM_REPAIR_WOULD_ACT). - The coder sees every integration's real arguments, and nobody is asked to
approve a call that is missing one (
ATOM_PARAMETERS_INVALID). On a live payment task: reaching approval 19/20 to 20/20, median 19.4 s to 8.7 s, input tokens 24.7k to 11.4k.
Removed¶
CoderSandbox._execute_local, unused, which gave generated code an undecidednexus_call.
Upgrading from 2.4¶
- Nothing is refused until you configure it. Report mode (the default) decides and records; it refuses only beyond a person's scopes or mandate, which you set. Adopt strict mode with Turning On Control.
- The journal is on by default (
JOURNAL_DIR=.jarviscore/journal), with replay content (JOURNAL_CAPTURE=full) kept 30 days. Point it at durable storage, or setJOURNAL_CAPTURE=digests, orJOURNAL_DIR=off. - Local Nexus:
jarviscore nexus upnow runs v0.7.0. SetNEXUS_SUBJECT_BINDING=requiredwhen agents act for your users.
2.4.1 2026-10-24¶
Fixed¶
- An approval covers only the arguments the person saw. A consequential
action's approval was looked up by its operation identity (the atom and its
idempotency fields), and the action then ran with whatever arguments the agent
passed. After a person approved "pay invoice INV-1, 10 to account A", a call
for INV-1 with another amount or account ran under that approval. 20 of the 155
shipped integrations that require approval take arguments outside their
identity (for example
cconmsgraph_send_email,from_emailonsendgrid_send_email,visibilityonlinkedin_create_post). An approval is now bound to every argument (for browser actions, to the element and values touched), and different arguments ask the person again. An operation that has already run still returns its recorded outcome, so it is never run twice. - The first decision on an action stands.
Mesh.resolve_hitlchecked that an action was undecided and then wrote the decision, so an approval and a refusal sent together could both pass the check and the last one won. The decision is now written atomically (resolve_hitl_action_once); the later one getsValueError.
2.4.0 2026-10-24¶
Changed¶
- Agents start in a fraction of the time. Opening the function registry
executed all 1,229 shipped atom modules to hold callables nothing asked for,
and merging the catalogue parsed every atom's contract twice even when the
stored source was the shipped source. A warm start spent 5 to 6 seconds
there and a cold one 4 to 14, before any work began. Callables now compile
on first
get_function(), an atom identical to the shipped one is skipped by hash, and each atom is parsed once. Warm registry open drops to about 0.25 s and a cold seed to about 2 s, with identical registry contents. - LLM calls keep their connection. The provider SDKs closed idle
connections after 5 s, shorter than the tool work between agent turns, so
most calls paid a new TCP and TLS handshake (about a second to a distant
region), and promotion and vLLM calls opened a new session every time.
Idle connections are now kept for
LLM_KEEPALIVE_SECONDS(default 120), promotion and vLLM calls reuse one session per event loop, and an agent opens its primary provider's connection while it starts (LLM_PREWARM). Measured against Azure: a call after an idle gap went from 2.9–3.2 s to 1.1–1.2 s, and an agent's first call from 2.9 s to 2.0 s. -
The observability guide says what a trace is. It described the per-step trace as suitable for replay and audit retention. It is a debugging record: LLM prompts and responses are previews, tool results are cut to 2,000 characters, routing, planning and evaluation calls are not yet traced, entries expire after seven days, and writes are best effort. The guide, the memory concept page and the tracer docstrings now say so, and the event table lists the fields the runtime writes.
-
Agent turns carry only what the agent can use. A working turn sent 19-29 tool schemas, each repeating a long note description, peer tools with no peers present, memory and workflow tools with nothing behind them, an echo tool that made the model write its answer twice, internal routing data, per-turn counters and a reasoning scaffold the model wrote out every call. Each is now offered only where it can act, and independent tool calls in one reply all run in the same turn. On a three-lookup support task: 5 calls and ~17k input tokens became 3 calls and ~5k, with output tokens cut by more than half.
- Tool programs. A sub-agent's own tools can be called from a Python
program in the Kernel's sandbox (
run_tool_program), so paging, filtering and totals happen in code and only the result reaches the model. Every call still runs through the agent's hooks and leaves a receipt. On an accounts-receivable task over 3,600 invoices, JarvisCore answered correctly for $0.024 in 21 s; LangGraph, CrewAI and Hermes, on the same model, spent $0.18-0.46 and 32-111 s and got it wrong. - The router answers tasks that need no role. Summarising or rewording what
the task gives is answered in the routing call (one model call instead of
two), on the model the communicator would use. Calculations still go to the
coder.
KERNEL_ROUTER_MAY_ANSWER=falseturns it off. - Each turn's prompt extends the last one, so providers serve it from cache. Tool definitions stay fixed for a run and the task leads the conversation. What the runtime tells the agent (the date, the budget at the start and again once a quarter remains, a warning before exchanges leave view) is said once and stays where it was said. Notes, receipts and recent actions are listed only for calls that have left view, exchanges leave view five at a time, and the run's workflow id no longer leads the task. On Azure, a prompt that strictly extends the last was served 9.1k of 9.2k tokens from cache; one whose closing message was replaced, 5.4k of 9.1k.
- Notes when they are needed. The agent is asked to note what it will still need when exchanges are about to leave view, instead of on every call; output tokens on a support ticket fell from ~550 to ~300.
- Receipts stay out of the answer.
donesays receipts are cited inresultastool_receipt_id, never in the summary; replies to customers had carried receipt ids in their prose. - Measured head to head (same model, three interleaved rounds), against the release before these turn changes: support lookups 1.8x cheaper, compute 1.7x, research 1.3x, five recurring tickets 2.2x (and 1.5x faster), with 26-78% of input now cached where none was. Against LangGraph and CrewAI, JarvisCore is 2-3x cheaper on a 360-invoice ledger and 26x on 3,600 invoices, where it alone answered correctly; on small tool tasks it still costs 1.2-3.6x more.
Added¶
UnifiedLLMClient.close()andPromoLLMClient.close()release the client's connections;AutoAgent.teardown()calls it. TheProfileteardown example already calledllm.close(), which did not exist.
Fixed¶
jarviscore inspectshows each tool call's arguments. The kernel's tracer records them asargsand the timeline read onlyparams, so every tool call in a real run printed without them.
2.3.1 2026-10-23¶
Fixed¶
- A goal returns what it delivered.
Mesh.execute_goal()andresume_goal()now returnoutput(the final step's delivered work) andevidence(every step's tool observations), asrun_task()does, andwaiting(the step paused for a person, with why). Before, callers had to dig them out ofsteps. A failed goal also carrieserror, the failing step's own reason. - A result is checked against its declared contract before it is accepted.
output_schemashaped thedonecall but its validators were never run, so a result that broke a rule the JSON schema cannot express (a reproduction needs a failing run) either passed or failed the whole step.doneis now refused with the rules that failed, and the agent fixes the result in its next turn. An agent that says it could not finish (complete: false) is not held to the contract. - The room agent's replies are written for people. A reply could end with a runtime receipt id ("Tool receipt: tool:room-…:1"); the agent is told not to, and any that slips through is removed before the reply is posted.
- Files the agents write under
output/reach the room. In a room or any bound workspace, the sandbox put its own scratch folder atoutput/and the change collector skipped every folder of that name, so a PDF an agent made was reported done but never proposed. The runtime's folder is.jarviscore/outputagain,output/is the project's own, and a write left out of a step's change is logged. - New work goes in a new file; a revision edits what it revises. Agents were told only to change "the room's files", so a new topic overwrote whatever file was there. They are now told to put new work in a new file, and a revision is given the files and text of the attempt it redoes.
- One version of a piece of work lands. Two people giving the same feedback
started two revisions, and the later one could be accepted over the team's
choice. A revision is now reserved before it starts, so feedback given at the
same moment is kept for it rather than starting another. Accepting a version
replaces what it revised, closes the other versions of that line of work
(and revisions built on them), and stops work still making one; decisions on
one line of work are made one at a time, and a version built on one the team
did not take cannot be accepted. Work that finishes after that files nothing
(
superseded). Revisions of held work stay held. - Nothing anyone adds to running work is lost. The room agent gains
update_work: an addition or correction to work in progress, or feedback on a proposal already being redone, is kept (ask.queued), and when the work ends one follow-up takes up every addition from its result, in the same thread. - A failed goal names the step that failed, not a step blocked behind it.
- The room agent knows what is running and how work ended. Its brief lists
running work, additions waiting, and recent results (including work that
changed no files), and it answers questions and agreement itself instead of
starting new work.
ask_agentsandroom.asktake a shorttitle; a proposal is no longer titled with the whole request. - A plan cut short says how to fix it. When a reasoning model spent its
whole output allowance thinking, planning failed with token counts only; the
error now names
LLM_MODEL_OUTPUT_LIMITSand the model to declare.
2.3.0 2026-10-22¶
Multiplayer: a team and its agents work on the same files, from Slack or your own product. Also a hardened local Nexus stack and Gateway API keys.
Added¶
- Multiplayer. People ask in their own words, agents propose changes, and
people decide as themselves. Start with
Build a Multiplayer Agent.
- Rooms (
Room): versioned shared files with roles, proposals, line-level merging, and work held for whoever's own access it used. RoomAgent: the agent the team talks to. It asks the agents and prepares decisions; people confirm them with one tap.- Chat surfaces:
RoomConversationconnects a room to any surface; Slack is built in (SlackApp,jarviscore room slack). - People as peers (
HumanAgent): planners route steps to people, who answer from a terminal, the CLI or a room's chat. - Testing without a model or a workspace:
MemorySurface,ScriptedRoomAgent,FakeSlack.
- Rooms (
- Room memory. A room remembers in Athena, or in the local store without
it. What work learns through someone's own access stays private to them.
room.forgeterases it all. - Per-person spending caps (
Spending) and an audit of who did what, with whose access and at what cost (Room.audit()). - Steps act for the person who asked (
context["acting_for"]): their own connections and access, in their name. - HITL: items record their step and tenant, and answering one resumes the
step.
HITL_TARGETSnames who responds;HITLQueue.assignroutes work to a person. mesh_worker = False, CustomAgents working on files with no extra code, andSTORAGE_BACKEND=redis.
Changed¶
- The bundled Athena stack is pinned to Athena v0.2.0 (authentication and per-tenant memory).
- Every Kernel role can open and change a step's files; only the coder runs commands.
- The new Browser Reference holds the detail behind a shorter Browser Automation guide.
Security¶
- Gateway API keys.
NexusClient,AuthenticationManagerand the CLI sendNEXUS_GATEWAY_API_KEYasX-API-Key. - The local Nexus stack is locked down. Nexus v0.6.7 now requires keys on the
broker and the gateway and listens on
127.0.0.1only; before, anything on your network could read stored credentials. - Agents no longer hold the encryption key. Stack secrets moved from
.envto~/.jarviscore/nexus/stack.env(mode 0600); agents get the gateway URL and key only. nexus registerprompts for secrets instead of taking them as flags.
Fixed¶
- The bundled Athena stack starts, keeps every event, and summarises with Azure deployments.
- Room work uses the room's tenant in Athena, not the deployment's default.
- HITL requests go to the people you name rather than a hard-coded "founder", and a reviewer's reason reaches the agent.
- A peer's first request to a node that has just joined is no longer dropped, and a step that fails on another node keeps its reason.
- The local vault derives its key once instead of on every credential read.
jarviscore atom test --mode integrationworks.
Removed¶
- The stale repository-root
docker-compose.nexus.ymland Nexus migration;jarviscore nexus inituses the bundled compose file.
Upgrading from 2.2¶
- Local Nexus: run
jarviscore nexus up. It moves the stack's keys out of.env(keeping the ones that decrypt your credentials) and restarts on v0.6.7. - A gateway you deploy yourself with
GATEWAY_REQUIRE_API_KEY=true: setNEXUS_GATEWAY_API_KEYon every agent host. - Athena: run
jarviscore memory init, thendocker exec athena ./ltm-purge-unscoped.
2.2.0 2026-10-22¶
One agent can run as several workers, every model call is paced to the provider's real limits, and agents act through native tool calls. Results come back with the evidence behind them, and the browser holds together on long, real tasks.
Added¶
- Elastic worker pools.
mesh.add(Agent, pool=Pool(min=1, max=8))runs one agent as several workers as work queues up. Verifying 196 claims took 9.4 minutes instead of 202. See RFC 0002. - Draining.
Mesh.drain()lets started goals finish without taking new work;stop()drains first. - Provider governor. Calls are admitted per deployment, grow while the
provider keeps up and back off on rate limits.
LLM_LIMITSshares limits across processes. See Provider governor. - Native tool turns on Azure, Claude, Gemini, Vertex AI and vLLM: every
turn is a real tool call, or
donetyped from the step'soutput_schema. - Working notes and a work record. Agents note what they have established
(never dropped from context), and every result carries
metadata["work_record"]. - Memory across runs with nothing to install, in
.jarviscore/memory/when Athena is not configured. - Consequential actions wait for a person. An action marked
irreversiblepauses the step;Mesh.resolve_hitl()resumes it, and the action runs once. - A browser for real tasks:
- page views as a person reads them, and every action returns the page it leaves behind;
findandactwith a decision model;run_playwrightprograms for repeated work, withread_pagesandopen_eachfor many pages and paged histories;- continuing across execution epochs, site pacing, and your own egress
proxy (
EGRESS_PROXY_URL).
See the Browser Reference.
- One runtime folder. Everything the framework writes goes under
./.jarviscore/. Thanks to @whoisnjoguu (#146).
Changed¶
- Answers come with evidence.
run_task()andworkflow()return the answer inoutputandresult_summary, and the tool observations inevidence. - Agents act as declared. A declared
default_kernel_roleis used, and only agents withrequires_auth = Truecan use provider credentials. - Memory follows the agent across restarts: it is keyed to the role rather than a per-process id.
- One instance, one piece of work. Add
pool=Pool(max=N)to run an agent's work in parallel. - Agents see every tool result whole, and later steps read what a step delivered, not its working state.
- The runtime records what an agent did instead of policing how it works. The runtime no longer clicks for the agent; leases, approvals, contracts and credential limits stay. See RFC 0003.
fill_formfills every kind of field. The browser offers fewer tools;run_playwrightcovers the rest.
Fixed¶
- Honest results. An agent that could not do the task reports
failurewith its reason. OnlyDONEcompletes a step, and receipts are never reused or invented. - Plain installs work. Keys in
.envreach every part of the runtime, the researcher reads web pages and PDFs without extras, logs report only real problems, and importing JarvisCore no longer loads a.envfile. - Workflows and the mesh. Tasks started in the same second get their own
steps, and an expired goal no longer stalls a node.
Mesh.stop()no longer hangs, pools no longer block the event loop, and the governor no longer strands calls. - Long steps hold together. Reaching the turn cap continues the step, and running out of budget keeps what was found. The next epoch finds what the last one read.
- The browser. Stale refs are refused, clickable rows and dropdown choices are visible, and approvals restore form values and run only once. A browser that goes away mid-step is reopened, and agents know the date.
- Research and memory. A research answer is the findings, not the working
state,
recall()keeps to its limit, and costs say where their price came from.
Known limitations¶
- Counting across many paged histories can still be off, though the data is read completely.
Upgrading from 2.1¶
- Runtime files moved to
./.jarviscore/. To keep the old folders, setSTORAGE_BASE_PATH=./blob_storage,LOG_DIRECTORY=./logsandTELEMETRY_TRACE_DIR=./traces. - Steps that must search or read declare it with
required_tool_groups. TheCONVERGENCE_*,FAILURE_GUARD_*andRESEARCH_*enforcement settings are ignored. - A turn with
RESULTbut noDONEno longer completes a step. - Resolve browser approvals with
Mesh.resolve_hitl(). - Parallel work for one agent needs
pool=Pool(max=N). - Agents that call providers declare
requires_auth = True. - A declared
default_kernel_rolebinds direct tasks; remove it to let the router choose. complete: falsenow returnsstatus: "failure"with the reason inerror.- Tool observations are in
result["evidence"];delegate()still returns the raw envelope. - Researcher results carry
summaryandevidence; the old checkpoint fields are gone. - The browser's model tools changed:
run_playwrightreplacesevaluate,wait_for,get_text,get_links,scroll,get_attribute,get_cookiesandclose_page.
2.1.1 2026-10-16¶
Fixed¶
- Peers that leave the mesh now leave every other node's roster. Remote
agents were added when a peer announced itself and never removed, so
peers.list_peers(),discover()and the Mesh capability catalog kept listing departed agents, and requests to them timed out.P2PCoordinator.stop()now sends a capability deannouncement before shutting SWIM down, so a clean exit leaves other rosters within a second. A crash sends no goodbye, and swim-p2p only reports a failure on the node whose own probes time out, so the coordinator also checks SWIM membership every two seconds and drops agents on nodes it declares dead. Suspect nodes are kept, and a dropped node that comes back alive is asked to announce again. (#267)
2.1.0 2026-10-06¶
Faster, more accurate evidence answers: retrieval that finds the right table row and cites it exactly, a planning step that can be skipped when the plan is known, and a researcher that actually reaches the browser and PDF tools in live runs.
Added¶
- Retrieval quality.
RagPipelineacceptsembed_model,query_instruction(prepended to queries only, for asymmetric models such as bge) and a cross-encoderrerank_modelthat rescores the vector shortlist in one batched pass. Also settable asRAG_QUERY_INSTRUCTION,RAG_RERANK_MODELandRAG_RERANK_CANDIDATES. Defaults are unchanged. - Declared index units and context.
ingest_documents()acceptsunits(exact spans to index, such as table rows) andcontext(embedded and reranked with each unit, never returned as quoted text). - Citation atoms. Documents may carry exact quotes with source locators; each result and evidence record carries the atoms whose quote it contains.
- Scoped retrieval and deletion.
retrieve(..., where={...})filters on metadata before ranking;store.delete(where)removes entries without re-embedding.one_per_source=Truekeeps only each source's best passage. - Plan templates.
execute_goal(..., plan_template=...)andsubmit_goal(..., plan_template=...)publish a validated DAG without a planning call; an invalid template is recorded and the goal is planned. - Final response passthrough. An agent with
final_response_passthroughpersists the single upstream artifact unchanged as the final response. - Declared crawler identity.
RESEARCH_USER_AGENTsets theUser-Agentresearch fetches send, as registers such as SEC EDGAR require.
Fixed¶
- The researcher reaches its browser and PDF tools in live runs. Its research phase and URL registry were read from state nothing bound, so live runs stayed in their first phase and browser tools were always blocked.
- Browser-rendered and PDF reads return content instead of failing on an undefined relevance scorer.
LLM_DEFAULT_MAX_TOKENSis honoured. The setting was dropped, so every call defaulted to 4,000 output tokens.- An exhausted lease continues in a new epoch before landing, so a run with epochs left no longer ends with a partial landing answer.
- Agents do not delegate to themselves.
ask_peerrefuses the requester's own role (PEER_REQUEST_TO_OWN_ROLE) and capability requests refuse its own capabilities; neither is offered in the tool descriptions. - A capability request is fulfilled only by a completed peer result, not by any status other than an error.
- Peer tool parameters are declared to the model, so it stops guessing
ask_capabilityfield names. - Published goals resume across deployments, with goal identity enforced and cancellation tombstones kept.
- Scoped RAG searches return results. Filters looked at top-level fields
while the pipeline stores caller fields under
metadata. - Search keeps a redirected page's final URL and page text keeps block boundaries and inline spacing.
- The default vector store opens on first use, so callers that bind their own store never open the default index.
Compatibility¶
Backward-compatible minor release. Retrieval defaults are unchanged; evidence quotes now hold the complete passage rather than its first 500 characters.
2.0.0 2026-10-06¶
JarvisCore now maintains its own atoms and runs the code its agents write safely. A major version because the atom contract is stricter: some atoms that were valid in 1.x are withheld until they declare what they do.
Breaking changes¶
- Atoms that send
POST,PUTorPATCHmust declareATOM_POLICY. Without one, such an atom was treated as a read that needs no approval, even when it created orders or sent messages. It is now withheld until it declares its effect. All 1,228 shipped atoms declare one. - Atom modules are declarative. At module level they hold only imports, constants and definitions; calls in decorators, defaults, annotations or base classes are rejected, so reading an atom never runs provider code.
- Atoms are called with their declared parameters only. Arguments are passed as data and unknown parameter names are rejected.
- Generated code reaches a provider only through its atoms. A direct
nexus_callto a provider that has registered atoms is refused unless the code is the atom being proven. - Apollo atoms use Apollo's current API.
apollo_search_people,apollo_get_personandapollo_search_organizationstake new parameters (titles, seniorities, employer domains; enrichment by id, name and domain, or LinkedIn URL; keyword tags), and the Apollo provider places its key in thex-api-keyheader. (#243)
Added¶
- Self-maintaining atoms. Coder repairs an atom that failed in the run, extends a read atom that ran but cannot cover a stated gap (additive, same policy), and proves a new read atom by one stated call before registering it. Every change becomes a new immutable registry version.
- OS confinement for model-written code. macOS
sandbox-execand Linuxbwrap: no network, reads limited to the runtime and workspace, writes only to the workspace, the function registry read-only. Model-written code now runs withoutALLOW_UNSAFE_LOCAL_EXECUTIONwherever confinement works. - Browser sessions.
BROWSER_CONTROL_URLattaches to a browser the person already has open;BROWSER_PROFILE_DIRkeeps a persistent profile per tenant. Screenshots reach the model as images on every provider. - Schedules and event triggers.
mesh.schedule_goal(),mesh.emit_event(),mesh.schedule_wake()andmesh.cancel_schedule()start durable goals on an interval, at a time or on an event, once across nodes. - Tool result observation settings.
SUBAGENT_OBSERVATION_LIMIT,SUBAGENT_TURN_RESULT_WINDOW,SUBAGENT_TURN_RESULT_BUDGETandSUBAGENT_READ_PAGE_LIMIT.
Fixed¶
- Tool results are kept whole. Retained results were cut at 16,000
characters, so a long listing lost its page token and agents re-listed until
their budget ran out. Older results are now released whole with a recorded
reason, and
read_turn_resultpages are shown whole. - An installed but blocked
bwrapis not confinement. Confinement is proven by starting one confined child; where a container forbids it, code execution is refused with the reason instead of every run failing. - The agent's answer reaches the person.
DONEcarries the human answer, memories an agent keeps flow into its result,rememberflushes before returning, andrecallincludes this session's memories. - Persistent browser profiles start. The profile metadata module was missing, so a persistent profile failed on import; screenshot bytes no longer flood the tool channel. (#220)
- Worker file tools stay inside the run workspace.
Migration¶
-
Check your own atoms with the contract reader. Each one that sends
POST,PUTorPATCHneeds anATOM_POLICY:from pathlib import Path from jarviscore.execution.atom_contract import read_contract for path in Path("my_atoms").glob("*/*.py"): # <system>/<atom>.py result = read_contract(path.read_text(), system=path.parent.name, expected_name=path.stem) if not result.ok: print(path, result.problems)ATOM_POLICY = { "effect": "write", # read, write, notify or destructive "approval": "never", # "required" for money, access, publishing "idempotency_fields": ["record_id", "fields"], "consequence": "Updates one record in Acme CRM.", }An atom that only queries through
POSTdeclares{"effect": "read", "approval": "never"}. -
Move any module-level calls in your atoms into the function body.
- Code that called the Apollo atoms with the old parameters must use the new ones above.
- In containers, allow user namespaces and an unmasked
/procfor confinement, or keep model-written code refused. See Sandbox Execution.
1.14.1 2026-10-01¶
The first 1.14 release on PyPI. 1.14.0 was tagged but not published because testing against the JarvisCore Agents blueprints found a regression, fixed here.
Added¶
- Declared model output ceilings.
LLM_MODEL_OUTPUT_LIMITS(JSON, model to completion ceiling) andLLM_DEFAULT_MAX_TOKENSset the default output allowance, so reasoning deployments no longer spend the whole allowance on hidden reasoning. Each fallback provider gets its own ceiling. (#242) - Tenant-scoped agent memory.
Mesh(config={"memory_scope_field": ...})names the trusted context field that separates tenants; a step without it gets no cross-session memory. (#244) InternetSearch.search_answered()returns results only when a search provider answered, and raisesSearchUnavailableotherwise.
Fixed¶
- Research must be performed. The researcher's completion gate needs a search that ran, a content read that returned something, a recorded finding or upstream step results. (#239, #246)
- A failed search is not an empty answer. HTTP errors, rate limits, open circuit breakers and CAPTCHA-blocked engines are reported as failures, not "no results".
- A plan revision keeps the work it doesn't redo.
- Reads draw on the thinking budget, by the tool's declared phase. (#240)
- A repaired protocol violation is forgiven after a well-formed turn. (#241)
- The planner reports why a completion stopped. (#242)
Compatibility¶
Backward-compatible minor release over 1.13.1. A researcher that finishes without searching or reading is asked to research, and a researcher whose searches all fail gets a failed tool result rather than an empty list.
1.14.0 2026-10-01¶
Tagged on GitHub but not published to PyPI; superseded by 1.14.1, which contains all of its changes.
1.13.1 2026-09-29¶
Fixed¶
- Cross-node notifications are delivered. JSON-encoded
peers.notify()payloads are decoded by the receiving coordinator. - Inbound peer messages are prompt. Requests arriving on the SWIM thread are handed to the agent's own event loop.
- Late joiners become visible. Nodes introduce their capabilities to every member that joins or recovers, not only at startup.
- Peer sends run on the transport's own loop, and introductions retry.
1.13.0 2026-09-22¶
Added¶
- Durable source workspaces now resolve GitHub repositories to immutable snapshots, materialize isolated copy-on-write sandboxes, compose dependency deltas, and preserve exact source provenance through distributed Mesh runs.
- Public typed artifact references and artifact-type dependencies let planners deliver exact upstream work products without copying or reconstructing evidence in prompts.
- Authoritative command and workspace-mutation receipts bind final artifacts to the tool executions and file contents that produced them.
- Coder workspace tools now include bounded listing, reading, searching, execution, complete-file writes, and hash-guarded line-range edits for safe modification of existing source files.
Changed¶
- Bounded execution epochs now preserve both cognitive state and cumulative workspace deltas. A later epoch can continue an earlier mutation and cite its original receipt without losing or fabricating evidence.
- Mesh final responses wait for semantic reconciliation. Rejected or partial evidence can produce a bounded corrective revision, while stale response steps are superseded before they can answer the user.
- Gateway-backed Nexus calls no longer require the local encrypted credential vault when a remote strategy is configured. Local fallback remains explicit and destination policy failures continue to fail closed.
- Same-store process restarts can resume node-local work when the persisted snapshot manifest is available; remote nodes still require shared storage.
Fixed¶
- Local generated-code and process execution now fails closed unless a trusted
deployment explicitly enables
ALLOW_UNSAFE_LOCAL_EXECUTION. Timeout cleanup terminates descendant processes on POSIX and Windows, and unsuccessful command results are retained as failure evidence. - Snapshot and delta persistence now rejects traversal, symlink, case-folded, identity, and mutable-blob collisions. Dependency deltas are accepted only from the framework-owned result field for the exact workflow step.
- Redis step output is bounded before persistence, including circular and unserializable values, while continuation state cannot retain a stale workspace delta from an earlier epoch.
- Cached source snapshots are bound to the requested source identity and commit, decoded GitHub payloads obey file and aggregate limits, and refreshed Nexus credentials are rechecked against destination policy.
- Prevented successful commands that execute zero tests from being treated as reproduction or verification evidence by product contracts.
- Prevented workspace writes from being lost between execution epochs and fixed final receipt hydration for mutations created before the terminal epoch.
- Prevented full-file replacement from masquerading as a targeted source edit by adding an optimistic-concurrency edit contract with source-hash validation.
- Fixed final-response races, stale revision responses, circular artifact dependencies, and resume-versus-amend lifecycle errors exposed by live Agent Desk execution.
1.12.0 2026-09-19¶
Added¶
- Native TypeSafe Jev decision-model support through an optional async client
for typed
Choice,Score, andNoulquestions. Mesh injects one shared client into agents, AutoAgent exposes the same capability as a thinking tool, and reported usage participates in workflow budgets and execution metadata. Verified against livejev-1.13.0withtypesafe-sdk0.7.0. - Opt-in Jev-backed Kernel subagent selection with complete probability, confidence, model, request, usage, and cost provenance. Explicit execution contracts and deterministic credentialed-system routing retain precedence.
- Opt-in Jev task-complexity classification now selects direct
nanoorstandardKernel execution versus the full Planner path. Low-confidence decisions preserve planning; provider failures retain the existing LLM classifier. - Optional post-retrieval Jev classification routes FAISS candidates into accepted, conflicting, and excluded views while retaining the complete shortlist and per-passage decision provenance.
jarviscore check --validate-typesafeperforms one live typed decision so a deployment can prove connectivity without writing agent code.
Fixed¶
- Jev-backed complexity classification, Kernel routing, and the AutoAgent
decision tool now preserve workflow-budget exhaustion as a durable
epoch_exhaustedresult so work can continue in a new execution epoch. - Concurrent RAG passage decisions cancel and join sibling requests before
propagating an error, and optional NumPy and FAISS imports remain lazy for
installations that do not enable the
ragextra. - TypeSafe client, Mesh shutdown, and CLI validation failures report sanitized exception classes without exposing provider response bodies or API-key fragments.
1.11.0 2026-09-11¶
Added¶
- Redis-backed
Mesh.execute_goal()compiles a natural-language goal into a source-grounded, capability-addressed DAG. Planning is a temporary leased operation; peers claim ready steps independently without an executor router. Mesh.resume_goal()resumes waiting work with executor affinity, andMesh.replan_goal()appends new work only for unresolved obligations through a revision-fenced DAG amendment while preserving the original goal and every prior attempt and output.- Terminal Mesh observation now separates execution completion from obligation
satisfaction. Evidence-bearing failures and semantic
hold/rejectoutcomes enter a bounded, revision-leased reconciliation decision: actionable gaps add new remediation work without replaying completed effects, while unactionable gaps settle durably. Results exposeobligation_statusandresponse_statusindependently of executionstatus. - AutoAgent kernels expose
list_peers,ask_peer,ask_capability,broadcast_update,read_mailbox,inspect_workflow, andread_workflow_step. Inbound peer requests work without application listener wiring, and notifications enter the durable mailbox before becoming reasoning context. - Generated-code sandboxes receive a restricted
meshfacade for peer listing and delegation. The child process cannot mutate Mesh lifecycle or registry state. - Redis workflow claims now use renewable leases, unique attempt tokens and fenced terminal writes, with append-only audit events for planning, claims, completion, failure, waiting, resume, recovery and DAG amendment.
- Distributed context, peer mandates, evidence and runtime limits now share one canonical envelope model. Capability requests have explicit terminal states, lineage-cycle prevention, lease heartbeats and bounded direct-Kernel execution.
- Step evaluation now includes an agent-owned goal convergence decision
(
continue,complete,replan) so newly observed facts can retire obsolete conditional work without domain-specific routing rules. - Final-response peers receive every workflow artifact, interpretation, step
state and current obligation projection through one
WorkflowEvidencesnapshot. Response selection uses the current revision while retaining older responses for audit. - Semantic dependency relevance is decided by the recipient peer from the upstream artifact and interpretation; Redis enforces execution readiness but does not turn a partial result into a global business decision.
- HITL now requires a canonical human-only category. Data requests additionally require proof that autonomous paths are exhausted and the missing decision or fact is exclusive to the human; confidence and token spend cannot escalate.
- Provider reads now preserve Calendar participant/state fields, export Google Workspace document content, and inspect HubSpot contact-deal associations so peers can decide from provider evidence rather than incomplete metadata.
- Failed registered atoms can enter an evidence-bound Coder repair lifecycle.
Only a contract-valid replacement that succeeds against the original
invocation can become immutable registry version
v+1; authentication and provider refusals do not automatically imply source repair. - Pre-effect review can return
already_satisfiedwith supporting evidence, completing a redundant mutation as a successful no-op. - LLM calls across planning, evaluation, reviews, distributed steps and nested peer mandates reserve and settle against one Redis-backed workflow token/cost account. Parallel peers no longer each receive the full workflow allowance.
- Peer tool schema and remote failures remain typed failures. Malformed calls do not count as peer-resolution attempts, while failed requests that actually reached a peer retain that attempt evidence.
1.10.0 2026-09-08¶
Long-running agents can now cross authentication and human-approval boundaries without losing their run, use several connected systems in one isolated execution, and return the artifact they actually produced.
Added¶
- A process-separated Coder runtime with a scrubbed environment. Generated code sends HTTP intent to the trusted parent over RPC; credentials remain in the parent and are host-bound before placement. This is a credential and process boundary, not OS/container isolation from the host filesystem.
- Durable consent, credential-input and destructive-action approval states. A run checkpoints before yielding and resumes the same workflow and step after the human decision.
- Provider discovery and self-seeding through the Nexus Gateway. A fresh process can discover active connections created elsewhere instead of asking for consent again.
- Per-call multi-provider routing with
nexus_call(method, url, provider="..."). Connected provider names reach the model as non-secret context; opaque handles and credentials do not. - Explicit destructive atom policy: consequence, required approval and parameter-backed idempotency identity. The shipped delete/remove corpus is classified, and reachable undeclared HTTP DELETE calls fail registration.
- Deliberate cross-session memory tools. Agents choose what to remember and recall by relevance; intermediate turns remain in recovery tiers rather than poisoning future tasks.
- A sanitized trace event sink for public activity views without raw thoughts, arguments, outputs or credentials.
Fixed¶
- Registered OAuth applications are no longer treated as connected accounts.
- Credentials can no longer be sent to a host owned by another provider.
- Auth and provider decisions no longer depend on matching status-code, provider-name or error-message substrings.
- OAuth waits no longer block inside a tool call or time out the run.
- Planned AutoAgent execution preserves the final structured step payload in
output; the evaluator's prose remains separately available asresult_summary. - Coder no longer auto-completes from a tool success, overwrites proof/result state, or exposes raw execution envelopes as the user answer.
- The process-separated runtime keeps advertised allow-listed commands such as
git,lsand Python available without inheriting the rest of the parent environment. - HTTP 401/403 remains credential-boundary evidence, not an automatic semantic verdict; typed connection state and lifecycle evidence drive recovery.
Validation¶
- Full local suite: 1,968 passed, 42 skipped, 1 expected failure on Python 3.12.
- Live Nexus calls verified against HubSpot, Google Drive, Gmail and Google Calendar, including a natural-language agent task spanning three providers.
- Built wheel includes the child runtime, provider host policy and destructive atom policy data.
1.9.0 2026-09-07¶
The shipped atom catalogue is callable. It was loaded but unusable: the atoms took a raw credential dict and built their own headers, and no caller for that shape existed, so agents rewrote integrations that were already on disk.
Added¶
- The atom catalogue is seeded when the registry is empty, so the Kernel's
registry-first search and the coder's
check_registryfind what ships. - 1,174 atoms across 150 providers migrated onto
nexus_call. An atom is nowasync def, authenticates through the call proxy, and returns provider errors rather than raising them. The credential never appears in the atom, so proving one works is running it. - An atom for the connected system arrives as a tool, the way every other tool does, rather than something the agent has to remember to look for.
--auth-type,--header-name,--value-prefix,--param-nameand--credential-fieldonjarviscore nexus register, so a provider that usesSSWS,Zoho-oauthtoken,PRIVATE-TOKEN,X-API-KEYor a query parameter can be registered without a code change.- Files written in the sandbox reach blob storage and come back as a durable handle, so an agent can read in a later run what it produced in an earlier one. Which backend that is remains the developer's choice.
Fixed¶
- Agent results were discarded. The sandbox awaited
main()and threw away its return value, so a run that succeeded reported "finished without returning any content". A returned dict was then read as the sandbox's own envelope, so an atom's payload vanished unless it happened to use a key nameddata. - Credential placement was guessed, and the two paths guessed differently.
The gateway path sent
X-Api-Keywhile the local store path sentAuthorization: Bearer, so which header a provider received depended on whether the gateway happened to be reachable. Both paths now apply one strategy, and placement is recorded per provider. resolve_strategyread the auth type from the wrong key. The gateway nests it understrategy, so every connection resolved asoauth2and received a bearer header regardless of its real type.- The local store passed a client secret off as an access token. Registering a provider's app is not the same as connecting an account, and saying otherwise turned a missing consent step into an opaque 401 inside an agent run.
- An API key registered without a stated location is refused with the flag to add, rather than sent as a bearer token the provider ignores.
jarviscore nexus registerrejected any provider missing from the built-in catalog, limiting registration to 22 providers while the framework ships atoms for 150. The catalog is defaults; flags override it.- The coder registered sandbox scripts as atoms after a successful run, putting entries in the catalog that could not be called, named from the task text, and promoting them on a success that had not happened.
google_driveandkraeach shipped atoms twice under different filenames, both files defining the same function. The catalogue advertised 1,224 where 1,218 exist.
Changed¶
- The bundled Nexus stack stands on its own: it ships its own Redis instead of
expecting a container from another compose project, publishes its ports
through
NEXUS_BROKER_PORTandNEXUS_GATEWAY_PORTso it can coexist with other services, and tells the broker its own address so OAuth redirect URIs are absolute rather than relative. nexus-brokerandnexus-gatewayare pinned to a release rather than followinglatest, so an upgrade is a decision. From broker v0.3.0 the broker carries and applies its own migrations, so JarvisCore no longer ships a copy of its schema. That copy is what drifted, surfacing as registration failures naming a column that did not exist.
Note for contributors¶
44 atoms across 11 providers still take auth_info. Each needs account
configuration, such as a tenant URL, turned into a parameter before it can move.
They are pinned in tests/test_atom_corpus.py so the number can only fall.
1.8.0 2026-09-06¶
1.6.0 and 1.7.0 were tagged but never published to PyPI
Both contain #170 — the Athena event write sat inside a branch that nothing
triggered, so no agent event reached the memory tier — and a nested f-string
in jarviscore/cli/atom.py that raises SyntaxError on import under Python
3.10 and 3.11. Their GitHub releases and changelog entries stand as history.
On PyPI, 1.8.0 follows 1.5.1 and contains everything from both.
Fixed
- Athena has stored nothing since 1.4.0 (#170).
_store_eventbuilt the request and then posted it insideif serialized_timestamp:._rfc3339(None)returnsNoneand nothing passes a timestamp —record_thought,record_action,record_observationand everyon_*helper call the write without one — so the request was assembled and dropped,store_eventreturnedFalse, and no caller checks the return. Any deployment withATHENA_URLset has an empty STM tier, and therefore no MTM chains and no cross-session recall, since both are summarised from events that were never written. The only test on the path used a fakeAthenaMemory, so it verified the layer above the broken one. - The Athena tier is self-healing and its delivery is countable (#128). Writes are
queued and shipped in order by one worker, so a slow Athena no longer adds
latency to a reasoning turn. A failed start opens a circuit breaker with a
cooldown probe instead of setting the client to
Nonefor the life of the process, which turned a thirty-second restart into a dead memory tier. A cached session id is checked before reuse: a 404 mints a new session and replaces the mapping, while an unreachable Athena keeps the id, because a network blink is not evidence that a session was deleted. - The planner and evaluator stop cutting inside a record (#166). Agent identity was
clipped to 400 characters twice, once by the caller and again in the
Plannerconstructor, so the component choosing the steps saw a persona without the rules that constrain it. The evaluator clipped the step summary and payload and then instructed the model never to fail a step merely because evidence was clipped — managing the damage rather than removing it. Evidence now goes in whole, and that instruction retires with the problem it was covering for. jarviscore/cli/atom.pycould not be imported on Python 3.10 or 3.11 (#167). Three print statements nested an f-string inside an f-string and reused the same quote in the replacement field, which is PEP 701 syntax valid only from 3.12.- PyYAML was never declared as a dependency although
AgentProfile.load()reads agent profiles from YAML on everyAutoAgentload, and returnedNonewith a warning when the import failed — an agent silently missing its role intelligence. It is now a dependency, and an unreadable profile raises.
Added
- A test job runs the suite on every pull request across Python 3.10, 3.11 and 3.12 (#167). CodeQL was previously the only check a pull request waited on. The suite was believed to have 38 permanent failures; every one was a missing dependency, and the real state is 1709 passing and none failing.
jarviscore.context.fidelity— spends a prompt budget on whole records in priority order and names what did not fit, instead of halving values.- Athena delivery counters on
AthenaMemory.delivery_statsandUnifiedMemory.athena_delivery_stats: submitted, shipped, retried, dropped, queue depth, breaker state and last success. AthenaClient.write_event, which raises instead of reportingFalse, andAthenaClient.session_exists.- Athena settings:
athena_outbox_max_events,athena_write_max_attempts,athena_breaker_threshold,athena_breaker_cooldown_seconds,athena_deduplicates_writes. Planning budgets:PLANNER_FACTS_BUDGET_CHARS,PLANNER_CONTEXT_BUDGET_CHARS,EVALUATOR_FACTS_BUDGET_CHARS.
Changed
EVALUATOR_SUMMARY_EVIDENCE_LIMITandEVALUATOR_PAYLOAD_EVIDENCE_LIMITare still read so existing configuration keeps importing, and no longer shorten anything.
Behaviour changes to know about (compatible, but read this)
- Athena writes are asynchronous.
record_thoughtand friends return once the event is queued. CallAthenaMemory.close()orUnifiedMemory.close()on shutdown to flush; both report whether anything was still unsent. - Write retries are off by default. Athena has no client-supplied deduplication
key, so replaying a write that actually landed would store it twice, and a memory
tier with invented corroboration is worse than one with a counted gap. JarvisCore
attaches an
idempotency_keyand retries only whenathena_deduplicates_writesis set — a claim about a deployment that only an operator can make. - The planner receives the whole system prompt.
system_prompt_excerptis still accepted as an argument name.
1.7.0 2026-09-06¶
Fixed
- A rejected
DONEnow tells the agent what it produced instead of what rule it broke (#144). The gate returned a verdict in its own vocabulary —DONE_VALIDATION_FAILED: evidence is required— and the observation was identical on every attempt, so nothing in the agent's input changed between the first rejection and the eighth. The facts already existed:_validate_done_payloadcomputesevidence_count,bad_evidence,bad_api_specsandincomplete_specson every call, and the report was discarded to return a sentence. A gate now names the check that did not hold, what it reads, and what it observed. The harness recognises an attempt that carries no new information — same check failing on the same values, same result submitted, no tool run in between — reports that too, and ends the step aftermax_identical_done_attempts(default 3) of them rather than spending the remaining lease re-submitting a rejected artifact. An agent that is still changing its output is never cut off. single_responsecan no longer report an unfinished completion as success (#148). A truncated answer, a refusal, a content-filter block and a completed answer were indistinguishable to the caller, because the provider's finish reason was discarded by every adapter before the profile could read it. Native reasons and completion metadata now travel with the response, and success requires a terminal reason. A missing reason staysNone— a generation that stops short of the cap is not evidence that it finished, and inferring one would manufacture the confidence this removes. Gemini output tokens now includethoughts_token_count, thought parts are excluded from content, andexecution_contract.max_output_tokensis honoured instead of ignored.- Search no longer cancels healthy grounded requests (#147). Every provider ran under one hard six-second deadline, so Gemini grounded search — a generative call — was routinely cut off and the run lost its highest-weight provider without saying so. Deadlines are now per provider (45s grounded, 15s otherwise) and configurable; a failing provider is named in the log with its error type and the deadline it exceeded, instead of an anonymous "Search provider failed".
- Docs and the packaged skill report the installed atom catalog rather than a count that was true when the page was written (#149).
Added
jarviscore.kernel.gate:GateEvidencefor reporting a completion failure as the check that did not hold plus what was observed, and the attempt ledger the harness uses to recognise a repeat.- Per-provider search deadlines via
RESEARCH_GROUNDED_TIMEOUT_SECONDSandRESEARCH_SEARCH_TIMEOUT_SECONDS, or constructor arguments on either publicInternetSearchclient. finish_reasonandprovider_metadataon every LLM response.
Behaviour changes to know about (compatible, but read this)
- A step can now end on an unsatisfied completion gate.
_can_completekeeps its(bool, reason)signature and a bare string is still accepted — carried through as a verdict with no observations behind it — but a gate that rejects the same unchanged attempt three times ends the step asFAIL_DONE_GATE_UNSATISFIEDinstead of running to the emergency turn fuse. The outcome names the gate rather than reporting "out of turns". - A single-response turn that used to succeed may now fail. Truncated, refused and filtered completions are reported as failures that name their cause. They were already failures; they were being reported as successes.
- Grounded search takes longer before giving up. The default grounded deadline is 45s. A run that previously lost that provider at six seconds will now wait for it, and return better evidence for the wait.
1.6.0 2026-09-06¶
Added
- Context pressure tiers replace per-value truncation (#154). Blocks are composed
at full fidelity and the least aggressive tier that fits the budget is chosen:
NORMAL→COMPRESS→EVICT_P3→EVICT_P2→RECOVERY. Under pressure whole blocks stop being inlined in priority order — mission and goal state are never evicted — and withheld records are named with the key they live under, so an agent retrieves a whole artifact instead of reasoning from a fragment of one. The active tier is rendered into the prompt and recorded ininternal_variables["context_pressure"].
Fixed
- An agent's
system_promptnow reaches the LLM in every sub-agent dispatch (#91). It was composed, passed to the kernel, stored in context and dropped: only the coder read it back, and only as a keyword check. Every researcher and communicator turn ran as a generic role stub, so authored personas, playbooks and guardrails had no effect. Identity now leads the system message, with the role prompt following as an execution harness. - A coder run that returns nothing no longer completes the task (#150).
_auto_completefired on any clean sandbox exit, so a run withdata: Noneand empty stdout was reported as a success whose "answer" was the execution envelope. Completion now requires a returned value, stdout, or a written file. - Missing credentials for a declared system yield for access instead of warning to
logs (#151). The kernel already knew no connection could be resolved; it now
returns the existing
YIELD_AUTH_REQUIREDcontract at that point rather than spending a dispatch on code that cannot authenticate. - Athena memory writes keep full fidelity (#153).
log_turnwrote the whole thought and result to the scratchpad and episodic ledger, then wrotethought[:500]andresult[:300]to Athena — the longest-retention tier held the only damaged copy, and mid-term chains were summarised from it. Domain events were clipped at 200–300 characters. A read may abridge and recover; a write cannot.
Changed
BudgetConfig's per-value character limits (context_value_limit,history_value_limit,memory_item_limit,belief_value_limit,internal_var_limit,prior_step_value_limit,state_keys_limit,summary_evidence_limit) are retained so existing configuration keeps importing, but no longer affect rendering.total_tokensstill scales from the lease profile.
Behaviour changes to know about (compatible, but read this)
- Prompts carry more, and reference the rest. Values are no longer cut, so a turn that previously showed 800 characters of a payload now shows all of it — or, under budget pressure, none of it plus a pointer. Agents that silently reasoned from fragments will now either see the whole record or be told where it is.
- A dispatch whose code returns nothing costs an extra turn instead of ending with a success it did not earn.
- A task declaring a system with no credentials yields instead of running. Declaring a provider is a statement of intent, so a mis-declaration now surfaces rather than failing obscurely later.
1.5.1 2026-09-04¶
Fixed
- Local Nexus vault was unreachable from agents (#142).
jarviscore nexus registerpromised "no further setup needed", butnexus_call()in the agent sandbox was always a raise-stub and the kernel only resolved connections through a gateway. Agents now get a real call proxy in both gateway and local-vault modes, and the kernel tags the opaque provider handle when the vault holds credentials. Agent code, prompts and generated code never see the token. - Traces omitted model and token data, and the scrubber redacted token counts (#143).
LLM trace events now carry
modelandtokens; the secret scrubber only redacts string values, since a token count is not a credential;jarviscore inspectrenders per-call models and no longer crashes on legacy scrubbed traces. claimer: "No agent found" for a step with no local agent is normal in distributed mode, and is now an info log with honest wording (#141).
Added
examples/demo_synthesizer.pyandexamples/demo_node_{1,2,3}.py: the four-process distributed research demo — SWIM gossip discovery, ledger-claimed steps, live web research, synthesis, and Slack delivery through the credential vault.examples/slack_notify_demo.py: minimal single-agent vault-to-Slack end-to-end.
1.5.0 2026-09-04¶
Fixed
- A rejected DONE no longer kills the agent as "Cognitive budget exhausted" (#139).
The done-gate rejection set
done_called, so an agent that tried to finish early was terminated the next turn under a label that named the wrong cause. Wall-clock interventions now fire at 40% and 15% remaining, exhaustion yields always name the dimension that expired, and a landing turn produces a partial result (SUCCESS_ON_LANDING) instead of dead air. - Settings
kernel_*andWORKFLOW_STEP_TIMEOUTenv knobs now reach lease enforcement (#135). Per-role profiles merge key-wise, so a partial override no longer drops the rest of the profile. - Researcher wall clock raised 240s → 600s and communicator → 360s (#136): the previous walls could not complete a modest real web-research task.
- SWIM probe budgets stop assuming idle round-trip times (#138, mitigation):
PING_TIMEOUTfloor 2s,SUSPECT_TIMEOUTfloor 15s, adaptive timing off by default.SWIM_*env vars still take precedence. Kept open for transport process isolation.
Added
mesh.workflow(timeout_per_step=...), per-steptimeoutkeys, and aWORKFLOW_STEP_TIMEOUTsetting (#137). The crash-recovery path resolves its own default.
Behaviour changes to know about (compatible, but read this)
- Agents run longer and may spend more by default. Runs that previously died
early now keep working; pin your own budgets via
kernel_role_profilesorKERNEL_*env vars if you depended on the old walls. - New success path. Runs that previously yielded on lease expiry can return
status="success"withtyped_outcome=SUCCESS_ON_LANDINGand a partial result. Checkmetadata["landing_turn"]to distinguish full from partial completions. - Slower peer-death detection. Set
SWIM_*env vars to restore tighter probes on dedicated transport hosts.
1.4.1 2026-09-02¶
Fixed
- Athena session creation now sends distinct
user_idandagent_idfields. Existing callers retain their prior user scope, while applications may opt into a shared user with separate agent memories. Redis session keys now include tenant, user, and agent identity to prevent cross-scope collisions.
1.4.0 2026-09-01¶
Added
- Athena v0.1.6 client parity for session reads/deletes, interactions,
query-aware context, metadata-filtered semantic search, topics, segments,
graph analytics, structured payloads, source timestamps, and durable event
IDs through
store_event_with_id(). - Optional
ATHENA_API_KEYandATHENA_JWT_TOKENauthentication headers.
Changed
store_event()remains boolean for compatibility while accepting optional timestamp, payload, and MIME arguments. Closed HTTP clients are recreated on the next request instead of permanently disabling Athena access.
1.3.2 2026-09-01¶
Fixed
- Athena v0.1.5
GetContextresponses now retain canonicalrelevantPagesas MTM chains instead of silently dropping cross-session summaries. The client also preserves segments, user persona, and LTPM status while keeping compatibility with legacy response aliases.
1.3.1¶
Added
-
Optional JarvisCore launch-promotion provider, for invited developers only. A
JARVISCORE_PROMO_TOKENgrants restricted hosted inference without exposing an upstream provider API key. Without a token nothing changes: JarvisCore uses your own configured providers exactly as before, and the promotion is neither reachable nor active.Promotional calls use a fixed Prescott endpoint, expose only the
jarviscore-promomodel alias rather than the upstream deployment, preserve the complete exchange under a stable call ID, and fail explicitly on expiry, exhaustion, or service errors rather than falling through to a paid provider — so an expired free entitlement can never quietly start billing your own account.The endpoint may be pointed at staging or a local instance with
JARVISCORE_PROMO_ENDPOINT. Overrides must be HTTPS and must resolve to a Prescott host or loopback: the promotional token is sent as a bearer credential, so an unrestricted override would be a way to harvest tokens rather than a convenience. -
jarviscore check --validate-llmreports promotional configuration and performs a real promotional inference request when asked.
Fixed
jarviscore initfailed on a pip-installed package withSource file not found: .../jarviscore/data/.env.minimal. The file was read by the scaffold command but never declared as package data, so it was absent from every published wheel and the first command a new user runs created nothing. Declared, along with the bundleddata/examples/*.pythat were similarly declared but missing from the repository.
1.3.0 2026-08-05¶
A developer-experience and integrations release. The atom catalog more than triples, memory setup becomes a one-command flow backed by a published image, traces become readable from the CLI, and AI editors get a first-class skill. Backward compatible; one security default changed (see Security below).
Added
- [#111] Atom catalog expansion: 104 new provider bundles (987 atoms) imported from our production function registry, bringing the catalog to 150 providers and 1224 atoms. Every ported provider was hand-verified atom by atom against the official vendor API documentation.
- [#103]
jarviscore inspect: read recorded traces from the CLI. Run list with steps, tokens, failures, and duration; per-step timelines;--errorsand--stepfilters; workflow id prefix matching; honest[clipped]markers on long values. - [#109] AI editor skill:
jarviscore init --skillinstalls a verified SKILL.md for GitHub Copilot and Claude Code, covering the real API contracts, profile decision rule, and common mistakes. The doc site now servesllms.txtand an AI Editors guide. - [#108] Image-first memory init:
jarviscore memory initpulls the published Athena image instead of cloning and building from source.--from-sourcekeeps the old path for contributors;memory upis now a working alias. - [#106] Minimal env scaffold:
jarviscore initwrites a focused 35-line .env template (one provider key gets you running);--fullwrites the complete reference.
Fixed
- [#106] Fresh-clone init: an unanchored
data/gitignore pattern meant packaged data files were never tracked, sojarviscore initfailed from any fresh clone. - [#111] Atoms never shipped:
integrations/atomswas neither a package nor declared package-data, so pip-installed wheels contained zero atom files andseed_registryfound nothing at runtime. - [#105] Silent import:
import jarviscoreno longer prints four lines of peer-to-peer module banners; the swim-p2p output is captured into debug logging and the p2p re-exports are lazy. - [#108] Memory CLI crashes:
memory initraisedNameError(missingPathimport) andmemory updid not exist.
Security
- [#110] TLS verification enforced: three code paths disabled certificate verification on outbound HTTPS, one of them while sending Bearer tokens. All outbound HTTPS now verifies against the certifi CA bundle. If you genuinely need to disable verification behind a corporate proxy, set
JARVISCORE_TLS_INSECURE=1; it logs a warning on every use.
Changed
- [#104] Documentation overhaul: landing page rewritten around enforced production rules, getting-started leads with a profile decision table, site-wide style pass, and the changelog page renders correctly.
1.2.0 2026-07-19¶
A large, fully backward-compatible release. It hardens the AutoAgent cognitive stack (context assembly, convergence, planning, evaluation), adds new orchestration and goal-mode primitives, and makes failures loud and honest across the board. Every change is additive: no public API was removed or altered, so upgrading from 1.1.0 is a drop-in.
Added
- [#52] Dynamic fan-out (
mesh.fanout()): run one task template over a runtime list of items with bounded concurrency, first-class partial failure (collectorfail_fast), per-item timeouts, and explicit aggregation via.aggregate()/.summarize(). Results are stamped with item and step identity so concurrent items cannot cross-contaminate. - [#73] Goal persistence and resume: goal executions persist after planning, after every completed step, and at terminal states, under
goals/{agent_id}/{goal_id}.json.execute_goal(resume_goal_id=...)rehydrates the plan, facts, and history so a crash loses at most the in-flight step. - [#74] Dependency-parallel planning: the planner declares
depends_onper step. Steps with no ordering constraint run concurrently (bounded byMAX_PARALLEL_STEPS), and a step never runs before its dependencies produce usable output. Plans without dependencies stay strictly sequential. - [#72] GOAL STATE context block: plan facts and completed-step outcomes now cross step boundaries as a structured, named block instead of one clipped generic line.
- [#69] Generational LTM compaction: long-term memory is bounded through incremental generational merges rather than unbounded growth or a destructive rewrite, with archives kept for retrieval.
- [#63]
single_responseexecution contract: AutoAgent can serve a one-completion analysis shape without the full planner or codegen, declared per task. The two-profile model (CustomAgent, AutoAgent) is preserved. - [#84] Partial-result preservation: a goal that stops before completing now returns the work it finished, tagged
[PARTIAL RESULT], instead of an empty result. Loud failures stay loud but hand back what they earned. - [#86] Local in-memory mailbox:
MailboxManagerworks without Redis for single-process meshes instead of raisingAttributeError. Multi-node durability still uses Redis. - [#88] Registry function identity: successful coder results carry a
function_idwhen a registry function was reused or promoted, so reuse is observable from the envelope.
Fixed
- [#57, #58] Observation and convergence integrity: the subagent observation channel no longer truncates silently, and the convergence governor stops raising false stalls from content-length equivalence or parameter-blind tool streaks.
- [#55, #56] Honest context assembly: every context clip carries an explicit marker, and key-cap overflow is announced by name instead of dropping state silently.
- [#61, #62] Directive precedence and step identity:
TOOLandDONEprecedence is resolved correctly, and every workflow result carries itsstep_id, including successes. - [#59] Zero-loss summarization: summarization compresses from real evidence and archives originals rather than discarding history.
- [#60] FailureLedger integrity: structured-first error classification with aligned guard keys, so retry policy is driven by real error types, not substring guesses.
- [#81, #82] HITL correctness:
HITL_ENABLEDis the single opt-in for every escalation path. Goals never dead-end waiting for a human on deployments that did not enable HITL. Evaluatorhitlverdicts are reserved for genuine human decisions, and the file-backed queueresolve()tocheck()round-trip now works. - [#85] Evaluator evidence: the evaluator sees enough of a step's output to judge it (tunable, generous windows with honest truncation markers), ending replan churn caused by verdicts made blind.
- [#87] Execution-backed coder reasoning: the coder's system prompt trains it to prove computed answers by executing code rather than answering from memory.
Changed
- [#83] Plan-mode boundary documentation: clarifies that plan mode is an AutoAgent capability which triages before planning, while CustomAgent treats planning as a library it calls.
- [#80] Fan-out guide fix: the workflow guide fan-out example now reads results from
output, matching the real result shape. - Documentation accuracy pass: corrected
blob_storage.load()references to the realread()API in the CustomAgent guide and troubleshooting page. - Removed internal-project references and development artifacts from the public tree.
1.1.0 2026-05-12¶
This release fixes all critical regressions introduced in v1.0.3 that rendered AutoAgent unusable, adds new AI engineering primitives (cognitive routing, intent normalization, structured output validation), and marks the beginning of strict SemVer compliance. Versions 1.0.3 and 1.0.4 are deprecated and will be yanked from PyPI.
Fixed
- [#32] Output schema enforcement:
Agent.output_schema(PydanticBaseModel) is now passed through the Kernel intoCoderSubAgent, which validates sandbox output against the schema viamodel_validate(). Schema violations fail fast with a clear error instead of silently returning unstructured data. - [#33] CoderSubAgent sandbox hallucination:
CoderSubAgent.get_system_prompt()now appends a dynamicSANDBOX ENVIRONMENTmanifest listing all pre-loaded modules and globals in the sandbox namespace. This grounds the LLM in what is actually available, preventing hallucinated imports and undefined-name errors. - [#34] Complexity gate before Planner:
AutoAgent.execute_task()now runs aTaskComplexityClassifierbefore dispatching to the Planner DAG. Non-complex tasks bypass the full Plan → Execute → Evaluate loop, while classifier contract failures now fail visibly instead of silently falling through to the Planner. - [#35] FunctionRegistry semantic search miss:
CoderSubAgent._tool_check_registry()now normalizes verbose task descriptions into concise canonical intents viaIntentNormalizerbefore callingsemantic_search(). This eliminates embedding distance drift caused by prompt verbosity. - [#36] AutoAgent vs CustomAgent boundary: Added
p2p_responderattribute to theAgentbase class (Falseby default,TrueonCustomAgent).JarvisLifespannow only creates backgroundasyncio.Taskinstances for agents withp2p_responder=True, and raisesRuntimeErrorat startup if ap2p_responderagent does not overriderun(). - [#37] Semantic vs execution status:
ResultHandler.process_result()now trackssemantic_successseparately from execution status.CoderSubAgent._tool_execute_code()includes an evaluator hook that flags outputs wheresuccess=Falseorstatus="failure"even when the sandbox execution itself succeeded. FixedTypeErrorwhencost_usdisNone. - [#38] Sandbox namespace leak into ZMQ coroutine cleanup:
SandboxExecutor._execute_sync()and_execute_async()now restorenamespace['__builtins__']to the actualbuiltinsmodule in afinallyblock. This preventsKeyError: '__builtins__'crashes in ZMQ's Cython backend during coroutine garbage collection. - Structured Kernel routing: keyword role matching has been replaced by a typed
TaskRouter. Explicit planner/profile roles are honored first; otherwise the router returns a validated role, confidence, reason, and evidence flag. Invalid or low-confidence routing fails visibly. Custom roles must registerkernel_role_profiles. - Strict subagent completion protocol: unparseable LLM responses now fail as protocol violations instead of being returned as successful raw content.
- Coder proof-of-work contract:
CoderSubAgentmust produce sandbox execution evidence before completion; structured prose results alone are no longer accepted for coder work. - Workflow terminal status handling: only
successcompletes a workflow step.yield,hitl,blocked,error, and unknown statuses are recorded as failures rather than satisfying dependencies. - WorkflowBuilder failure visibility: agent-returned
failure,yield,blocked,hitl, or unknown statuses are now preserved instead of being wrapped as stepsuccess. - Distributed workflow output integrity: a remote step marked
completedwithout persisted output now returns failure rather than fabricating a successful empty result. - AutoAgent Kernel failure visibility: Kernel exceptions now return an explicit failure instead of silently falling back to the legacy direct-codegen pipeline.
- Profile routing explicitness: missing
default_kernel_rolein a profile no longer impliescommunicator; applications must opt into profile-level routing hints. _run_contextAttributeError in CoderSubAgent: Changed direct attribute access togetattr(self, '_run_context', {})to preventAttributeErrorwhen_run_contextis not yet initialized.
Added
TaskComplexityClassifier(jarviscore.planning.classifier): LLM-based cognitive router that classifies tasks as "trivial", "moderate", or "complex" to determine whether the full Planner DAG is needed.IntentNormalizer(jarviscore.execution.intent_normalizer): Distills verbose task descriptions into concise canonical intents for accurate embedding-based semantic search.Agent.p2p_responderattribute: Boolean flag distinguishing reactive task workers (AutoAgent) from proactive mesh citizens (CustomAgent) at the framework level.Agent.output_schemaattribute: Optional PydanticBaseModelclass for end-to-end structured output validation through the Kernel pipeline.semantic_successfield inResultHandlerresult data: Enables downstream consumers to distinguish between "code ran without errors" and "task actually achieved its goal".SandboxExecutor.get_manifest()/CoderSandbox.get_manifest(): Introspect the sandbox namespace for prompt injection into the CoderSubAgent system prompt.
Deprecated
- Versions
1.0.3and1.0.4: contain critical AutoAgent regressions. Will be yanked from PyPI. Users should pin>=1.1.0.
1.0.4 2026-05-11¶
Documentation
- Mobile drawer fully resolved: Level 1 nav items clickable on all viewports, back arrow restored, site name text hidden in mobile view.
- Section
index.mdentry points added for Concepts, Guides, and Reference: each section now has an overview landing page with icon cards. - CSS tab icons removed from sections that use frontmatter-defined icons, eliminating duplication.
- README expanded and restructured with additional examples and API reference.
Fixed
- Deprecated
Mesh(mode='distributed')calls replaced with explicitconfig={"p2p_enabled": True}intest_09_distributed_autoagent.pyandtest_10_distributed_customagent.py.
1.0.3 2026-05-08¶
Documentation
- Launched the full MkDocs documentation site: Getting Started, Concepts, Guides, Reference, Examples, and Enterprise sections.
- New guides: AutoAgent, CustomAgent, Workflows, Chat, HITL, Nexus, Knowledge Base, System Prompts, Observability, FastAPI Integration, Internet Search, Migration (CrewAI + LangGraph), Testing.
- New concept pages: Architecture, Memory, Nexus, P2P, System Bundles, Agent Personas.
- New examples: Financial Pipeline, Research Network, Support Swarm, Content Pipeline, Investment Committee.
- Synced all 15 brand SVG variants to
docs/assets/and removed legacy unreferencedlogo.png/logo.svg. guides/testing.md: documentedExampleMockLLMClient: tool-validating mock LLM for unit testing agents with tool use.- Fixed deprecated
Mesh(mode=...)calls inREADME.md,guides/production.md,guides/browser-automation.md, andguides/adapters.md.
Added
mesh.run_task(agent, task, context, complexity): primary user-facing API for dispatching a single task to an agent by role with multi-tier model routing.P2P_ENABLED=trueenv var support:Settings.p2p_enabledis now merged into Mesh config at startup.HITLCategoryenum with hard enforcement onHITLQueue.request(): valid categories:auth_required,data_required,critical_action. Invalid categories raiseValueError.- Planner subagent hints are strict: valid hints are accepted exactly and invalid hints fail visibly instead of being remapped.
STEP_OUTPUT_MAX_BYTES(default 200 KB) andSTEP_OUTPUT_PREVIEW_BYTES(default 20 KB): large step outputs stored as truncated preview with_overflowflag.- Idempotent write guard on
RedisStore.save_step_output(): a successful result will not be overwritten by a subsequent error payload from a stalled re-execution. - Azure Content Filter visibility in
LLMClient: raw provider content-filter rejections now fail visibly by default.AZURE_CONTENT_FILTER_REPAIR_ENABLED=trueexplicitly opts into Azure-specific prompt repair after the raw prompt is rejected. Kernel._get_model_for_tier(): clean multi-tier model resolution: complexity hint →TASK_MODEL_NANO/TASK_MODEL_STANDARD/TASK_MODEL_HEAVY→ legacy fallback.MailboxManagerschema normalisation: handles both the current flat envelope schema and the pre-v1.0.2 double-nested schema transparently.- Vertex AI provider (
LLMProvider.VERTEX_AI): GCP-native Gemini access via Application Default Credentials (ADC). No API key required: authenticate withgcloud auth application-default loginor attach a service account. Config:VERTEX_AI_ENABLED=true,VERTEX_AI_PROJECT,VERTEX_AI_LOCATION(defaultus-central1),VERTEX_AI_MODEL(defaultgemini-2.5-flash). Slots into the fallback chain after Gemini: Azure → Claude → vLLM → Gemini → Vertex AI. _normalize_tools_for_gemini()static method: auto-converts tool schemas to Geminifunction_declarationsformat. Accepts Anthropic/PeerTool (input_schema), flat (name+parameters), or already-native formats.- Shared
_call_genai_client()helper: both_call_geminiand_call_vertex_aidelegate here for consistent token accounting and cost calculation. - Tool-call response parsing in
_call_genai_client: when a Gemini/Vertex AI response containsfunction_callparts,tool_callsis populated andcontentis set to"". - Token pricing entries for
gemini-2.5-flash,gemini-2.5-pro,gemini-3.1-pro,gemini-3.1-pro-preview. - Process-wide LLM concurrency semaphore (
LLM_MAX_CONCURRENTenv var): prevents thundering-herd 429s in multi-agent deployments. llm.nano_modelandllm.planner_modelproperties: tier-aware model selection forStepEvaluatorandPlanner.max_completion_tokensalias ingenerate(): callers can use GPT-5.x SDK naming convention interchangeably withmax_tokens.
Fixed
P2P_ENABLEDenv var was not forwarded toMesh.config, requiringconfig={"p2p_enabled": True}explicitly even when the env var was set.- HITL escalations could be raised for arbitrary reasons, polluting the human review queue. Now enforced at the framework level.
- Planner emitted
Unknown subagent_hintwarnings for semantically valid but aliased LLM role names. - Examples audit (2026-05-07): fixed API compatibility across all 5 production examples for v1.0.3 breaking changes.
- SWIM stabilisation replaced hardcoded 5 s sleep with condition-based poll (0.3 s for single-node; up to 5 s when seed nodes configured).
AutoAgentresult dict now exposespayloadas a dedicated top-level key when the output is a structured dict, enabling downstream step access without manual parsing.- Crash recovery
_resume()pre-populates recovered step results intopre_resultsso resumed workflows replay correctly rather than skipping completed steps. ExampleMockLLMClientvalidates tool names against thetoolsparameter before returning tool-use responses, preventing mock deadlocks when a tool is out of scope._call_gemininow forwards**kwargs(includingtools) to_call_genai_client, making Gemini tool-calling behaviour consistent with Vertex AI.test_claude_primarynow passes an explicit config that disables all other providers, making the assertion environment-independent.
Changed
mesh.workflow()no longer restricted to autonomous mode: works across all mesh configurations.- CLI references updated from
python -m jarviscore.cli.*to thejarviscoreentry-point CLI.
1.0.2 2026-03-04¶
Fixed
- P2P Keepalive Spam Prevention: Added exponential backoff mechanism (45s default) to prevent continuous keepalive attempts when peers are unavailable or network has connectivity issues.
- Remote Agent Discovery Bug: Fixed
PeerClient.list_roles()to include remote agents from SWIM mesh, not just local agents. Previously only checked local agent registry, missing agents discovered via P2P network. - Single-Node Graceful Degradation: Added
allow_zero_peersflag (default: True) to recognize single-node runs as valid state without triggering failure warnings.
Changed
- Increased
ask_peertimeout from 600s to 7200s (2 hours) to support long-running database queries and complex analysis tasks. - Enhanced keepalive manager with consecutive failure tracking and backoff-until timestamp for better network resilience.
- Improved keepalive logging to distinguish between expected zero-peer state and actual failures.
Added
P2P_KEEPALIVE_FAILURE_BACKOFF_SECONDSconfig parameter (default: 45) for keepalive retry backoff.P2P_ALLOW_ZERO_PEERSconfig parameter (default: True) for single-node development and testing.
1.0.1 2026-02-27¶
Fixed
- LICENSE link in README resolves to 404 on PyPI. Replaced relative path with absolute GitHub URL.
1.0.0 2026-02-25¶
Changed
- Version: 0.4.0 → 1.0.0: stable public release.
- Documentation URL updated to custom domain:
https://jarviscore.developers.prescottdata.io/
Added
- Apache 2.0 license (replaces MIT); CLA/INDIVIDUAL.md, CLA/CORPORATE.md, TRADEMARK.md.
- CONTRIBUTING.md with CLA links, ruff tooling, PR checklist.
- CODE_OF_CONDUCT.md community standards.
- ENTERPRISE.md for OSS vs Enterprise comparison.
examples/investment_committee/: 7-agent multi-step workflow with web dashboard (AutoAgent + CustomAgent, parallel step execution, LTM institutional memory, FastAPI dashboard on port 8004).
0.4.0 2026-02-19¶
This was the largest release in JarvisCore history, introducing the complete infrastructure stack across nine phases. It added persistent storage, context distillation, telemetry, the mailbox messaging system, the function registry, the Kernel OODA loop, distributed workflow execution, Nexus authentication, and the unified memory architecture.
Phase 1: Foundation Layer
LocalBlobStorage / AzureBlobStorage with save(path, data) / load(path) for any artifact. RedisContextStore for full Redis-backed step output, workflow graph, mailbox, HITL, and checkpoint methods. Configured via STORAGE_BACKEND, STORAGE_BASE_PATH, and REDIS_URL.
Phase 2: Context Distillation
Evidence, TruthFact, TruthContext, AgentOutput Pydantic models. distill_output(), scrub_sensitive(), merge_facts() utilities. ContextManager for token-budget aware prompt building (priority stack: mission → plan → scratchpad → LTM → tool history → variables). JarvisContext enhanced with truth, mailbox, tracer, human_tasks fields.
Phase 3: Telemetry and Tracing
TraceEventType enum covering workflow, step, kernel cognition, tool, mailbox, HITL, and context events. TraceManager with three output channels: Redis List (persistent), Redis PubSub (real-time), and JSONL (compliance fallback). record_step_execution(duration, status) Prometheus histogram and counter, enabled via PROMETHEUS_ENABLED=true.
Phase 4: MailboxManager
self.mailbox.send(target_id, payload) / read(max_messages) for async agent messaging. Backed by Redis Streams, available in all modes when REDIS_URL is set.
Phase 5: Function Registry
CodeRegistry auto-registers successfully executed code per task and promotes to VERIFIED on first success. Available as agent.code_registry in AutoAgent, persisted to {log_dir}/function_registry/. Includes update_execution_stats(func_name, success, execution_time) for graduation tracking.
Phase 6: Kernel / SubAgent OODA Loop
The Kernel replaces AutoAgent's linear codegen → sandbox → repair pipeline with a supervised OODA loop. ExecutionLease enforces token/turn/wall-clock budgets per subagent role. AgentCognitionManager tracks budget spend per phase, detects spinning (same tool 3+ times), and enforces cognitive gates. AdaptiveHITLPolicy with HumanTask pauses execution when confidence or risk triggers fire. Coder dispatches require executable proof of work before completion.
Phase 7: Distributed WorkflowEngine
WorkflowEngine persists DAG to Redis hash workflow_graph:{wf_id} for crash recovery. When no local agent matches a step, the engine resets status to "pending" and polls Redis. Mesh._run_distributed_worker() scans jarviscore:active_workflows, checks are_dependencies_met(), atomically claims steps via SETNX, executes, and writes output to Redis.
Phase 7D: AuthenticationManager (Nexus)
Set requires_auth = True on any agent and the Mesh injects self._auth_manager before setup(). Full NexusClient flow: request_connection → browser OAuth → poll ACTIVE → resolve_strategy → apply headers. Graceful degradation when NEXUS_GATEWAY_URL is not set.
Phase 8: Memory Architecture
UnifiedMemory(workflow_id, step_id, agent_id, redis_store, blob_storage) with .episodic (EpisodicLedger via Redis Streams), .ltm (LongTermMemory via Redis), and .scratch (in-memory WorkingScratchpad). RedisMemoryAccessor reads step outputs across the workflow.
Phase 9: Mesh Integration and Auto-Injection
Before each agent's setup(), the Mesh injects _redis_store, _blob_storage, and mailbox. Prometheus server starts automatically when PROMETHEUS_ENABLED=true. Agents use injected infrastructure directly with zero boilerplate.
Production Examples
financial_pipeline.py: AutoAgent autonomous, 3-step financial analysis pipeline.research_synthesizer.py+research_node_1/2/3.py: AutoAgent 4-node SWIM research cluster.support_swarm.py: CustomAgent P2P, 4-agent support routing with Nexus auth.content_pipeline.py: CustomAgent distributed, content pipeline with LTM.
Fixed
AutoAgent.execute_task: passcontext=task.get('context')tosandbox.execute()so LLM-generated code can accessprevious_step_results.
Changed
- P2P env var namespace:
bind_port,bind_host,seed_nodes,node_namenow read fromJARVISCORE_BIND_PORT,JARVISCORE_BIND_HOST,JARVISCORE_SEED_NODES,JARVISCORE_NODE_NAMErespectively. This isolates per-process P2P settings from the swim package's own env vars.
0.3.2 2026-02-04¶
Added
Session Context Propagation: context parameter added to notify(), request(), respond(), and broadcast() methods. Context carries metadata like mission_id, priority, trace_id across message flows. respond() automatically propagates context from request if not overridden.
response = await peers.request("analyst", {"q": "..."}, context={"mission_id": "abc"})
async def on_peer_request(self, msg):
mission_id = msg.context.get("mission_id")
return {"result": "..."}
Mesh Diagnostics: mesh.get_diagnostics() returns local_node, known_peers, local_agents, and connectivity_status (healthy, isolated, degraded, not_started, local_only). Includes SWIM and keepalive status when P2P is enabled.
Async Request Pattern: ask_async(target, message, timeout, context) returns a request_id immediately. check_inbox(request_id, timeout, remove) retrieves the response later. Enables fire-and-forget workflows where you collect results when ready.
Load Balancing Strategies: strategy parameter on discover() supports "first", "random", "round_robin", and "least_recent". discover_one() convenience method for single peer lookup.
MockMesh Testing Utilities: jarviscore.testing module with MockPeerClient (full mock with discovery, messaging, assertion helpers) and MockMesh (simplified mesh without real P2P infrastructure). Auto-injects MockPeerClient into agents during MockMesh.start().
0.3.1 2026-02-02¶
Breaking Changes
ListenerAgent has been merged into CustomAgent. Migration requires only an import change:
# Before
from jarviscore.profiles import ListenerAgent
# After
from jarviscore.profiles import CustomAgent
All handler methods work exactly the same way. No other code changes required.
Changed
CustomAgent now includes P2P handlers: on_peer_request(msg), on_peer_notify(msg), on_error(error, msg), and the built-in run() listener loop. The profile architecture was simplified from three profiles (AutoAgent + CustomAgent + ListenerAgent) to two (AutoAgent + CustomAgent), removing the "which profile do I use?" confusion.
0.3.0 2026-01-29¶
Added
ListenerAgent Profile: New ListenerAgent class for handler-based P2P communication with on_peer_request(msg) and on_peer_notify(msg) handlers. No more manual run() loops required for simple P2P agents.
FastAPI Integration: JarvisLifespan context manager reduces FastAPI integration from approximately 100 lines to 3. Automatic agent lifecycle management with support for both p2p and distributed modes.
Cognitive Discovery: peers.get_cognitive_context() generates LLM-ready peer descriptions with dynamic peer awareness. Auto-updates when peers join or leave the mesh.
Cloud Deployment: agent.join_mesh(seed_nodes) for self-registration without central orchestrator. agent.leave_mesh() for graceful departure. agent.serve_forever() for container deployments. RemoteAgentProxy for automatic cross-node agent visibility.
0.2.1 2026-01-23¶
Fixed
- P2P message routing stability improvements.
- Workflow engine dependency resolution edge cases.
0.2.0 2026-01-22¶
Added
CustomAgent profile for integrating existing agent code. P2P mode for direct agent-to-agent communication. Distributed mode combining workflow engine with P2P. @jarvis_agent decorator for wrapping existing classes. wrap() function for wrapping existing instances. JarvisContext for workflow context access. Peer tools: ask_peer, broadcast, list_peers.
Changed
Mesh now supports three modes: autonomous, p2p, distributed. Agent base class now includes P2P support.
0.1.1 2026-01-16¶
Changed
- Migrated from the deprecated
google.generativeaiSDK to the currentgoogle.genaiSDK. - Updated default Gemini model to
gemini-2.0-flash.
Added
- Scaffold CLI (
python -m jarviscore.cli.scaffold) for new project initialization. - Bundled
.env.exampleand example files in the PyPI distribution.
0.1.0 2026-01-13¶
Added
Initial release. AutoAgent profile with LLM-powered code generation. Workflow engine with dependency management. Sandbox execution (local and remote). Auto-repair for failed code. Internet search integration (DuckDuckGo). Multi-provider LLM support (Claude, OpenAI, Azure, Gemini). Result storage and code registry.


