Skip to content

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 evidence and people.account now 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.finished event lists its systems.
  • A policy refusal says it was the policy. PolicyDenied and 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, _resume and _new_execution_epoch are left out of the agent's input context; code reads them as before.
  • Clearer evidence output. jarviscore verify says "(1 refused before approval)" rather than "(0 refused, 1 refused before approval)"; jarviscore evidence names the effect and integration of a call refused for a missing scope, and shows agent=- 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; strict refuses 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 | scopes validates 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_assertion for approvals signed by your backend). An approved action runs at most once; one interrupted mid-run is left OUTCOME_UNKNOWN for 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) on run_task, execute_goal, submit_goal, workflow and create_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.connect starts 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_by requires an approver holding a scope within its limit. See the guide.
  • A verifiable journal. Decisions and effects are written as hash-linked events; jarviscore verify checks a journal (or a copy) offline. jarviscore evidence acme/u_1 lists what agents did for a person or tenant, --export hands it to their auditor (verify --export), and --erase removes a person's replay content while the journal still verifies. Records hold methods, hosts, paths and decisions, never bodies or credentials.
  • Replay. jarviscore replay re-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_CAPTURE and JOURNAL_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 jarviscore takes 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 undecided nexus_call.

Upgrading from 2.4

  1. 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.
  2. 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 set JOURNAL_CAPTURE=digests, or JOURNAL_DIR=off.
  3. Local Nexus: jarviscore nexus up now runs v0.7.0. Set NEXUS_SUBJECT_BINDING=required when 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 cc on msgraph_send_email, from_email on sendgrid_send_email, visibility on linkedin_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_hitl checked 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 gets ValueError.

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=false turns 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. done says receipts are cited in result as tool_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() and PromoLLMClient.close() release the client's connections; AutoAgent.teardown() calls it. The Profile teardown example already called llm.close(), which did not exist.

Fixed

  • jarviscore inspect shows each tool call's arguments. The kernel's tracer records them as args and the timeline read only params, 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() and resume_goal() now return output (the final step's delivered work) and evidence (every step's tool observations), as run_task() does, and waiting (the step paused for a person, with why). Before, callers had to dig them out of steps. A failed goal also carries error, the failing step's own reason.
  • A result is checked against its declared contract before it is accepted. output_schema shaped the done call 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. done is 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 at output/ 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/output again, 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_agents and room.ask take a short title; 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_LIMITS and 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: RoomConversation connects 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.
  • 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.forget erases 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_TARGETS names who responds; HITLQueue.assign routes work to a person.
  • mesh_worker = False, CustomAgents working on files with no extra code, and STORAGE_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, AuthenticationManager and the CLI send NEXUS_GATEWAY_API_KEY as X-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.1 only; before, anything on your network could read stored credentials.
  • Agents no longer hold the encryption key. Stack secrets moved from .env to ~/.jarviscore/nexus/stack.env (mode 0600); agents get the gateway URL and key only.
  • nexus register prompts 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 integration works.

Removed

  • The stale repository-root docker-compose.nexus.yml and Nexus migration; jarviscore nexus init uses the bundled compose file.

Upgrading from 2.2

  1. 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.
  2. A gateway you deploy yourself with GATEWAY_REQUIRE_API_KEY=true: set NEXUS_GATEWAY_API_KEY on every agent host.
  3. Athena: run jarviscore memory init, then docker 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_LIMITS shares 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 done typed from the step's output_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 irreversible pauses 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;
    • find and act with a decision model;
    • run_playwright programs for repeated work, with read_pages and open_each for 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() and workflow() return the answer in output and result_summary, and the tool observations in evidence.
  • Agents act as declared. A declared default_kernel_role is used, and only agents with requires_auth = True can 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_form fills every kind of field. The browser offers fewer tools; run_playwright covers the rest.

Fixed

  • Honest results. An agent that could not do the task reports failure with its reason. Only DONE completes a step, and receipts are never reused or invented.
  • Plain installs work. Keys in .env reach 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 .env file.
  • 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

  1. Runtime files moved to ./.jarviscore/. To keep the old folders, set STORAGE_BASE_PATH=./blob_storage, LOG_DIRECTORY=./logs and TELEMETRY_TRACE_DIR=./traces.
  2. Steps that must search or read declare it with required_tool_groups. The CONVERGENCE_*, FAILURE_GUARD_* and RESEARCH_* enforcement settings are ignored.
  3. A turn with RESULT but no DONE no longer completes a step.
  4. Resolve browser approvals with Mesh.resolve_hitl().
  5. Parallel work for one agent needs pool=Pool(max=N).
  6. Agents that call providers declare requires_auth = True.
  7. A declared default_kernel_role binds direct tasks; remove it to let the router choose.
  8. complete: false now returns status: "failure" with the reason in error.
  9. Tool observations are in result["evidence"]; delegate() still returns the raw envelope.
  10. Researcher results carry summary and evidence; the old checkpoint fields are gone.
  11. The browser's model tools changed: run_playwright replaces evaluate, wait_for, get_text, get_links, scroll, get_attribute, get_cookies and close_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. RagPipeline accepts embed_model, query_instruction (prepended to queries only, for asymmetric models such as bge) and a cross-encoder rerank_model that rescores the vector shortlist in one batched pass. Also settable as RAG_QUERY_INSTRUCTION, RAG_RERANK_MODEL and RAG_RERANK_CANDIDATES. Defaults are unchanged.
  • Declared index units and context. ingest_documents() accepts units (exact spans to index, such as table rows) and context (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=True keeps only each source's best passage.
  • Plan templates. execute_goal(..., plan_template=...) and submit_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_passthrough persists the single upstream artifact unchanged as the final response.
  • Declared crawler identity. RESEARCH_USER_AGENT sets the User-Agent research 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_TOKENS is 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_peer refuses 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_capability field 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, PUT or PATCH must declare ATOM_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_call to 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_person and apollo_search_organizations take 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 the x-api-key header. (#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-exec and Linux bwrap: no network, reads limited to the runtime and workspace, writes only to the workspace, the function registry read-only. Model-written code now runs without ALLOW_UNSAFE_LOCAL_EXECUTION wherever confinement works.
  • Browser sessions. BROWSER_CONTROL_URL attaches to a browser the person already has open; BROWSER_PROFILE_DIR keeps 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() and mesh.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_BUDGET and SUBAGENT_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_result pages are shown whole.
  • An installed but blocked bwrap is 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. DONE carries the human answer, memories an agent keeps flow into its result, remember flushes before returning, and recall includes 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

  1. Check your own atoms with the contract reader. Each one that sends POST, PUT or PATCH needs an ATOM_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 POST declares {"effect": "read", "approval": "never"}.

  2. Move any module-level calls in your atoms into the function body.

  3. Code that called the Apollo atoms with the old parameters must use the new ones above.
  4. In containers, allow user namespaces and an unmasked /proc for 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) and LLM_DEFAULT_MAX_TOKENS set 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 raises SearchUnavailable otherwise.

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, and Noul questions. 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 live jev-1.13.0 with typesafe-sdk 0.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 nano or standard Kernel 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-typesafe performs 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_exhausted result 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 rag extra.
  • 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, and Mesh.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/reject outcomes enter a bounded, revision-leased reconciliation decision: actionable gaps add new remediation work without replaying completed effects, while unactionable gaps settle durably. Results expose obligation_status and response_status independently of execution status.
  • AutoAgent kernels expose list_peers, ask_peer, ask_capability, broadcast_update, read_mailbox, inspect_workflow, and read_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 mesh facade 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 WorkflowEvidence snapshot. 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_satisfied with 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 as result_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, ls and 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_registry find what ships.
  • 1,174 atoms across 150 providers migrated onto nexus_call. An atom is now async 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-name and --credential-field on jarviscore nexus register, so a provider that uses SSWS, Zoho-oauthtoken, PRIVATE-TOKEN, X-API-KEY or 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 named data.
  • Credential placement was guessed, and the two paths guessed differently. The gateway path sent X-Api-Key while the local store path sent Authorization: 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_strategy read the auth type from the wrong key. The gateway nests it under strategy, so every connection resolved as oauth2 and 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 register rejected 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_drive and kra each 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_PORT and NEXUS_GATEWAY_PORT so it can coexist with other services, and tells the broker its own address so OAuth redirect URIs are absolute rather than relative.
  • nexus-broker and nexus-gateway are pinned to a release rather than following latest, 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_event built the request and then posted it inside if serialized_timestamp:. _rfc3339(None) returns None and nothing passes a timestamp — record_thought, record_action, record_observation and every on_* helper call the write without one — so the request was assembled and dropped, store_event returned False, and no caller checks the return. Any deployment with ATHENA_URL set 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 fake AthenaMemory, 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 None for 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 Planner constructor, 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.py could 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 every AutoAgent load, and returned None with 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_stats and UnifiedMemory.athena_delivery_stats: submitted, shipped, retried, dropped, queue depth, breaker state and last success.
  • AthenaClient.write_event, which raises instead of reporting False, and AthenaClient.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_LIMIT and EVALUATOR_PAYLOAD_EVIDENCE_LIMIT are 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_thought and friends return once the event is queued. Call AthenaMemory.close() or UnifiedMemory.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_key and retries only when athena_deduplicates_writes is set — a claim about a deployment that only an operator can make.
  • The planner receives the whole system prompt. system_prompt_excerpt is still accepted as an argument name.

1.7.0 2026-09-06

Fixed

  • A rejected DONE now 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_payload computes evidence_count, bad_evidence, bad_api_specs and incomplete_specs on 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 after max_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_response can 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 stays None — 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 include thoughts_token_count, thought parts are excluded from content, and execution_contract.max_output_tokens is 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: GateEvidence for 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_SECONDS and RESEARCH_SEARCH_TIMEOUT_SECONDS, or constructor arguments on either public InternetSearch client.
  • finish_reason and provider_metadata on every LLM response.

Behaviour changes to know about (compatible, but read this)

  • A step can now end on an unsatisfied completion gate. _can_complete keeps 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 as FAIL_DONE_GATE_UNSATISFIED instead 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 in internal_variables["context_pressure"].

Fixed

  • An agent's system_prompt now 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_complete fired on any clean sandbox exit, so a run with data: None and 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_REQUIRED contract at that point rather than spending a dispatch on code that cannot authenticate.
  • Athena memory writes keep full fidelity (#153). log_turn wrote the whole thought and result to the scratchpad and episodic ledger, then wrote thought[:500] and result[: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_tokens still 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 register promised "no further setup needed", but nexus_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 model and tokens; the secret scrubber only redacts string values, since a token count is not a credential; jarviscore inspect renders 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.py and examples/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_* and WORKFLOW_STEP_TIMEOUT env 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_TIMEOUT floor 2s, SUSPECT_TIMEOUT floor 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-step timeout keys, and a WORKFLOW_STEP_TIMEOUT setting (#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_profiles or KERNEL_* env vars if you depended on the old walls.
  • New success path. Runs that previously yielded on lease expiry can return status="success" with typed_outcome=SUCCESS_ON_LANDING and a partial result. Check metadata["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_id and agent_id fields. 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_KEY and ATHENA_JWT_TOKEN authentication 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 GetContext responses now retain canonical relevantPages as 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_TOKEN grants 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-promo model 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-llm reports promotional configuration and performs a real promotional inference request when asked.

Fixed

  • jarviscore init failed on a pip-installed package with Source 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 bundled data/examples/*.py that 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; --errors and --step filters; workflow id prefix matching; honest [clipped] markers on long values.
  • [#109] AI editor skill: jarviscore init --skill installs 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 serves llms.txt and an AI Editors guide.
  • [#108] Image-first memory init: jarviscore memory init pulls the published Athena image instead of cloning and building from source. --from-source keeps the old path for contributors; memory up is now a working alias.
  • [#106] Minimal env scaffold: jarviscore init writes a focused 35-line .env template (one provider key gets you running); --full writes the complete reference.

Fixed

  • [#106] Fresh-clone init: an unanchored data/ gitignore pattern meant packaged data files were never tracked, so jarviscore init failed from any fresh clone.
  • [#111] Atoms never shipped: integrations/atoms was neither a package nor declared package-data, so pip-installed wheels contained zero atom files and seed_registry found nothing at runtime.
  • [#105] Silent import: import jarviscore no 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 init raised NameError (missing Path import) and memory up did 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 (collect or fail_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_on per step. Steps with no ordering constraint run concurrently (bounded by MAX_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_response execution 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: MailboxManager works without Redis for single-process meshes instead of raising AttributeError. Multi-node durability still uses Redis.
  • [#88] Registry function identity: successful coder results carry a function_id when 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: TOOL and DONE precedence is resolved correctly, and every workflow result carries its step_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_ENABLED is the single opt-in for every escalation path. Goals never dead-end waiting for a human on deployments that did not enable HITL. Evaluator hitl verdicts are reserved for genuine human decisions, and the file-backed queue resolve() to check() 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 real read() 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 (Pydantic BaseModel) is now passed through the Kernel into CoderSubAgent, which validates sandbox output against the schema via model_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 dynamic SANDBOX ENVIRONMENT manifest 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 a TaskComplexityClassifier before 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 via IntentNormalizer before calling semantic_search(). This eliminates embedding distance drift caused by prompt verbosity.
  • [#36] AutoAgent vs CustomAgent boundary: Added p2p_responder attribute to the Agent base class (False by default, True on CustomAgent). JarvisLifespan now only creates background asyncio.Task instances for agents with p2p_responder=True, and raises RuntimeError at startup if a p2p_responder agent does not override run().
  • [#37] Semantic vs execution status: ResultHandler.process_result() now tracks semantic_success separately from execution status. CoderSubAgent._tool_execute_code() includes an evaluator hook that flags outputs where success=False or status="failure" even when the sandbox execution itself succeeded. Fixed TypeError when cost_usd is None.
  • [#38] Sandbox namespace leak into ZMQ coroutine cleanup: SandboxExecutor._execute_sync() and _execute_async() now restore namespace['__builtins__'] to the actual builtins module in a finally block. This prevents KeyError: '__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 register kernel_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: CoderSubAgent must produce sandbox execution evidence before completion; structured prose results alone are no longer accepted for coder work.
  • Workflow terminal status handling: only success completes 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 step success.
  • Distributed workflow output integrity: a remote step marked completed without 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_role in a profile no longer implies communicator; applications must opt into profile-level routing hints.
  • _run_context AttributeError in CoderSubAgent: Changed direct attribute access to getattr(self, '_run_context', {}) to prevent AttributeError when _run_context is 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_responder attribute: Boolean flag distinguishing reactive task workers (AutoAgent) from proactive mesh citizens (CustomAgent) at the framework level.
  • Agent.output_schema attribute: Optional Pydantic BaseModel class for end-to-end structured output validation through the Kernel pipeline.
  • semantic_success field in ResultHandler result 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.3 and 1.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.md entry 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 explicit config={"p2p_enabled": True} in test_09_distributed_autoagent.py and test_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 unreferenced logo.png / logo.svg.
  • guides/testing.md: documented ExampleMockLLMClient: tool-validating mock LLM for unit testing agents with tool use.
  • Fixed deprecated Mesh(mode=...) calls in README.md, guides/production.md, guides/browser-automation.md, and guides/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=true env var support: Settings.p2p_enabled is now merged into Mesh config at startup.
  • HITLCategory enum with hard enforcement on HITLQueue.request(): valid categories: auth_required, data_required, critical_action. Invalid categories raise ValueError.
  • 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) and STEP_OUTPUT_PREVIEW_BYTES (default 20 KB): large step outputs stored as truncated preview with _overflow flag.
  • 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=true explicitly 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.
  • MailboxManager schema 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 with gcloud auth application-default login or attach a service account. Config: VERTEX_AI_ENABLED=true, VERTEX_AI_PROJECT, VERTEX_AI_LOCATION (default us-central1), VERTEX_AI_MODEL (default gemini-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 Gemini function_declarations format. Accepts Anthropic/PeerTool (input_schema), flat (name+parameters), or already-native formats.
  • Shared _call_genai_client() helper: both _call_gemini and _call_vertex_ai delegate here for consistent token accounting and cost calculation.
  • Tool-call response parsing in _call_genai_client: when a Gemini/Vertex AI response contains function_call parts, tool_calls is populated and content is 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_CONCURRENT env var): prevents thundering-herd 429s in multi-agent deployments.
  • llm.nano_model and llm.planner_model properties: tier-aware model selection for StepEvaluator and Planner.
  • max_completion_tokens alias in generate(): callers can use GPT-5.x SDK naming convention interchangeably with max_tokens.

Fixed

  • P2P_ENABLED env var was not forwarded to Mesh.config, requiring config={"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_hint warnings 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).
  • AutoAgent result dict now exposes payload as 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 into pre_results so resumed workflows replay correctly rather than skipping completed steps.
  • ExampleMockLLMClient validates tool names against the tools parameter before returning tool-use responses, preventing mock deadlocks when a tool is out of scope.
  • _call_gemini now forwards **kwargs (including tools) to _call_genai_client, making Gemini tool-calling behaviour consistent with Vertex AI.
  • test_claude_primary now 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 the jarviscore entry-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_peers flag (default: True) to recognize single-node runs as valid state without triggering failure warnings.

Changed

  • Increased ask_peer timeout 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_SECONDS config parameter (default: 45) for keepalive retry backoff.
  • P2P_ALLOW_ZERO_PEERS config 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: pass context=task.get('context') to sandbox.execute() so LLM-generated code can access previous_step_results.

Changed

  • P2P env var namespace: bind_port, bind_host, seed_nodes, node_name now read from JARVISCORE_BIND_PORT, JARVISCORE_BIND_HOST, JARVISCORE_SEED_NODES, JARVISCORE_NODE_NAME respectively. 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.generativeai SDK to the current google.genai SDK.
  • Updated default Gemini model to gemini-2.0-flash.

Added

  • Scaffold CLI (python -m jarviscore.cli.scaffold) for new project initialization.
  • Bundled .env.example and 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.