Repository navigation
[0.1.3] - dash fixes and much more
[0.1.3] - 2026-11-06
Added
- Resume a stopped run where it stopped.
- Resume where it stopped on a halted, failed or cancelled run, or
POST /runs/{id}/continue,
starts a new run (resumed_from_id) with the same council, outputs and knowledge, optionally
with changed guardrails. - Every agent task the old run finished (plan, steps, report stages, votes) is replayed from its
recorded answer, with no model call and no step counted. Only unfinished work calls a model. - Citations keep their numbers. Notes and workspace files carry over.
- Each finished task is now recorded as
task.completed. For older runs, the plan and finished
steps are recovered from their events, and the report is built again. - Before this, the only way on was Start a follow-up run, which began again from planning.
- Resume where it stopped on a halted, failed or cancelled run, or
- Budget reserve.
budget.buffer_usd/budget.buffer_tokensis spending approved in advance. The run draws it,
without asking, when it reaches its budget, instead of halting. This works even with limit
extensions off.- The report pipeline counts the reserve, so it no longer drops stages to fit the base budget.
- Set it in the guardrails editor or Home's run settings (remembered per browser).
- On a live run, the Budget control or
POST /runs/{id}/budgetraises the budget now
(add_usd,add_tokens) or sets the reserve (buffer_usd,buffer_tokens).
- The run timeline shows a resumed run's origin, a drawn reserve and budget changes at every
density. - Council members talk to each other, and to you, over A2A.
- Every seat gets the communication tools, whatever its role's tool list says (the run's
tools.allow/tools.denystill apply):send_message,message_group,broadcast,
publish/subscribe(topics),ask_agent,delegate_task,request_review,
reply_to_user, and the board'snotes_write/notes_read. They cover eight forms: direct,
request, broadcast, group, delegate, topic, board and review. ask_agent,delegate_taskandrequest_reviewrun the recipient on the request at once and
bring its answer back. A run allows 40 of them, nested at most two deep. A review's verdict is
also posted to the board.- Every member sees the shared board on every turn, and each finished step is posted to it.
Messages from teammates arrive at the recipient's next turn. - Every exchange is an A2A
Message(a delegation also an A2ATask), each member has an A2A
agent card (argus://runs/{run}/agents/{member}, in-process transport), and each exchange is
recorded in the ledger (protocola2a, directioninternal) and on the timeline as
a2a.message/a2a.taskevents. - The run timeline shows each exchange as a row, and the map and heatmap draw it as an A2A edge.
- Your messages during a run are A2A messages with role
user. Addressed members get them at
their next turn and keep them in their instructions for the rest of the run. They answer with
reply_to_user, shown as Ben replied to you. POST /runs/{id}/a2atakes an A2Amessage/sendmessage (metadata.to: a member's name or
role; omitted, the whole council) and returns the recorded message.
- Every seat gets the communication tools, whatever its role's tool list says (the run's
- The council debates and concludes together. See the design.
- Debate over A2A. Members make claims with evidence and a confidence (
make_claim), and
challenge a claim or a teammate (challenge), demanding proof, a counterexample or a
clarification. The challenged member must defend, concede or revise
(respond_to_challenge), and the challenger accepts or rejects the answer
(resolve_challenge).- A defence of a proof demand that brings no evidence is marked unsupported and stays open.
- A member cannot finish its work while challenges against it are open: it is sent back up to
debate.max_nudgestimes. - A review that asks for a revision opens a challenge.
- Every move is an A2A message with a
datapart. Each one is recorded in the ledger and on
the timeline asdebate.*events.
- A collective conclusion. After the work come four phases. Every non-overseer member is a
debater and a co-author.- Deliberate: rounds in which all debaters challenge at once, then answer at once.
- Converge: every debater states a position, endorsing or objecting to each claim. Agreement
is computed in code againstdebate.consensus(two thirds by default), and the debaters
revise while claims stay contested. - Compile: a scribe (the writer seat, or else the chair) assembles only what was agreed,
shows contested claims with both sides, records dissent, and adds How the council reached
this. - Co-sign: every author signs, amends or blocks, with a quorum. Amendments that the consensus
endorses are applied. - Co-signing replaces the vote, in report mode too, where the report's byline lists the
council.debate.enabled: falserestores one synthesis and a majority vote.
- Debate cost. The debate saves without cutting rounds, participants or the threshold:
- Light moves (a challenge, a position, a signature, an amendment vote) read a digest. They run
as one call without tools, on the newest cheap model of the seat's own provider that still
scores at leastdebate.light_min_reasoning(70) for reasoning. That is Claude Haiku 5.5 for
a Claude seat, with the seat's model as the fallback. - Answers to challenges, which keep the read-only tools to fetch proof, and the compiled text
stay on the seat's model. - A debater shown nothing new since its last challenge is not asked again.
- Each phase reports its cost as
debate.cost, and the Debate view shows the total. debate.light_model: "seat"keeps every move on the seat's model.
- Light moves (a challenge, a position, a signature, an amendment vote) read a digest. They run
- A secret devil's advocate. At the start of a run, one debater (never an overseer or the
chair) is picked at random in code to argue the other side and demand proof. The pick needs at
least two debaters, and is skipped and recorded otherwise.- Only you know who it is. The run records
council.role_assignedwithsecret: true, and the
UI shows the badge with a private marker. - No agent is told. The stance never reaches a roster, agent card, board, inbox, digest, the
graph or the deliverable. - Giveaway phrases are removed from everything the advocate says, writes or thinks into a
shared place: messages, notes, claims, tool arguments, the live view and graph nodes. - A resumed run keeps the same advocate.
- Only you know who it is. The run records
- The Debate tab. It shows the phase and round, the numbered claims with their status and
evidence, each challenge as a thread, a table of members' positions on the key claims, and the
conclusion's signatures. From any claim or challenge you can message the member.
- Debate over A2A. Members make claims with evidence and a confidence (
- Truly parallel by default.
- Eight agents work at once (
max_parallel_agentswas 4). - The read-only tools and council (A2A) tools an agent calls in one turn run concurrently, and
their results come back in call order. A turn with a writing, shell or approval-gated tool
keeps the calls in order. - Every member sees what its teammates are doing right now: a Working now section with the tail
of each teammate's latest thought (member.live).
- Eight agents work at once (
- Runtime helpers. Any member can bring in helpers while it works with
spawn_agents, waiting
for them or collecting them later withawait_agents.- A helper is a council member for as long as it lives. It is an A2A task with its own agent card.
It sees the board, can make claims and challenge others while it works, can spawn helpers of
its own, and can be held, corrected or messaged like a seat. It takes no position and does not
co-sign: the conclusion belongs to the seated council. - The model is chosen for the role from the council's providers.
- Helpers run in parallel through the run's slots. The limits are in
guardrails.spawn
(max_agents8,max_depth2,max_live6). - The chair can add plan steps mid-run (
add_step), and they start as soon as their
dependencies are done. - Cancelling the run cancels its helpers. Resume replays both helpers and added steps.
- A helper is a council member for as long as it lives. It is an A2A task with its own agent card.
- Graph context: fewer tokens, and a council that remembers. Each council keeps a knowledge
graph (tablesgraph_nodesandgraph_edges, migration0021).- The graph holds claims, evidence, results, entities, decisions and open questions, linked by
supports, refutes, cites and derived-from edges. - It is built from the run's events with no model calls.
- Instead of pasting up to 24k characters of earlier steps, a step gets a digest of each
dependency: its summary and claims, with ids. Members read detail on demand withgraph_read,
search withgraph_queryand link nodes withgraph_link. - The board is rendered from the graph.
- A new run starts from what this council already knows: the nodes from its earlier runs that
best match the topic. - On a two-step offline run, the dependent step's context fell from 8,247 to 1,792 characters.
Each step reports its saving ascontext.saved, shown in the run header. - On Anthropic models, the stable part of the system prompt and the tools are sent with
cache_control, so turns after the first read them from the prompt cache. guardrails.graphturns this off or tunes it.
- The graph holds claims, evidence, results, entities, decisions and open questions, linked by
- Shared knowledge between runs.
- A new run inherits the board of the latest earlier run of the same council, or of your runs
without a council. That's the newest 40 notes, marked (earlier run) and credited to their
authors, and the run after inherits them again.graph.inherit_board: falseturns this off. - Every note on the board is recorded as a
board.noteevent. - Agents are told about all the knowledge they can search: the linked knowledge bases (searched
first), every other knowledge base you added, and the research library. Before, they were told
only about the linked ones.
- A new run inherits the board of the latest earlier run of the same council, or of your runs
- A compressor, and budget pressure.
- Older turns are summarised on the cheapest model of the seat's provider that scores at least
context.compressor_min_reasoning(70) for reasoning, instead of the seat's own model. - Once a run has used
context.pressure_start(60%) of its token ceiling, every agent's history
budget shrinks, down to 40% at the ceiling, so turns cost less as the run nears it. The ceiling
counts the limit, the raises still allowed and the reserve: 5,000,000 tokens by default. - The run records
context.pressureonce per tenth of the ceiling.
- Older turns are summarised on the cheapest model of the seat's provider that scores at least
- Recovery from context overflow. When a model refuses a prompt as too long, the agent halves
its history budget, summarises and tries again, up to twice, as Claude Code does
(context.compacted). Before, the step failed, and with it often the run. - See how each agent reasons. Thought cards gain a Reasoning section above the answer. It
updates live, collapses once the answer arrives, and shows the token count.oversight.reasoning:auto(the default) records what the model returns, at no extra cost;onasks Claude (adaptive thinking, summarized) and Gemini 2.5 (thoughts) for a readable
summary;offrecords none.
- Reasoning is streamed as
thought.reasoning.deltaand kept onthought.completed. - It is shown only to you, never to another agent, and the secret advocate's reasoning is
concealed like the rest.
- Readable JSON replies. Plans render as numbered step lists. Debate moves, co-signatures,
votes and reviews render as labelled rows with chips, and other JSON as a collapsible tree, each
with View raw and Copy JSON. - Auto mode. With
guardrails.auto_modeon, agents never stop to ask. Each approval request is
still recorded, asapproval.requestedthenapproval.resolved {"decision": "approved", "by": "auto"}, and the workspace shows it as Auto-approved.guardrails.extensions.auto_approve
does the same for raising the step, per-agent turn, runtime and token limits. It stays within
extensions.limitsandmax_extensions, and only raises spend whenbudget.usdis listed. Both
switches are on Home's run settings (remembered per browser) and in the council guardrails
editor.POST /runs/{id}/auto-modeand an Auto mode control next to Pause change them on a
live run; turning one on approves the requests already waiting that it covers. Hard blocks
(tools.deny, destructive shell, content and network policy) are unchanged. Sub-councils
inherit auto mode. - Palettes. Settings → Appearance, the header theme menu and the command palette offer six
palettes, each in light and dark: Wine (default), Indigo (the original look), Graphite, Forest,
Ocean and Ember.scripts/check-contrast.pychecks every palette against WCAG AA. - The protocol ledger also records the agents' outbound web requests:
web_fetch,web_search
and the market and news tools, as protocolhttp. The live stream gets aprotocol.callevent
for each request. The ledger page has an HTTP filter. Before this, the ledger stayed empty for
anyone without MCP servers or remote agents. web_fetchreads PDFs (up to 15 MB). It can render JavaScript-only pages in headless Chromium
whenARGUS_WEB_FETCH_RENDER_JS=trueand the optionalbrowserextra (Playwright) is installed.- Released images on the GitHub Container Registry.
- Every release publishes
ghcr.io/lordprime/argus-council/{api,web,runner}as<version>,
<major>.<minor>andlatest. They are scanned with Trivy before they are pushed. deploy/docker-compose.ymlruns those images by default, so a server needs only that file and
an.env: no checkout and no build. Each GitHub release attaches the compose file with its
version pinned, and the.envexample.- A release starts from a pushed
v*tag, or from Actions → Release → Run workflow with a
version (it creates the tag atref, or with move_tag moves an existing one for a
re-release). The version must matchbackend/pyproject.tomlandfrontend/package.json. deploy.sh --release <version>andupdate.sh --release <version>pull a release instead of
building, with the usual backup, migration step and automatic rollback.- Building from source still works: the scripts build local
argus-council/*images as before,
anddeploy/docker-compose.build.ymladds the build sections back for plain Compose.
- Every release publishes
Changed
- The schema gains
runs.resumed_from_id(migration 0020). notes_writeposts to the council board, which is shown to every member on every turn; before,
notes were seen only throughnotes_read.- Ledger entries can have direction
internal(between members of one council), shown as
Council in the ledger browser. - The Insights dashboard is rebuilt.
- Each headline number shows its change against the previous window of the same length.
- Runs per day are stacked by outcome, next to a Right now panel of live runs and the ones
waiting for your approval. - Spend over time sits beside spend by model.
- Tool reliability is now a table: error rate, calls, average time, and each tool's most
common error. - It also has a model and provider health table, oversight with the auto-approved share, the
run mix, top failures, guardrail violations, and the costliest runs. GET /insightsaddsprevious_totals, a per-hour or per-dayseries(computed on the
server, no longer from the newest 200 runs), each tool'stop_errorsand
oversight.approvals_auto.- Charts follow one set of rules: status colours mean status and nothing else, gridlines are
solid, bars are thin, and headline numbers are set in the sans face.
- The runs list includes
pending_approvalsfor live runs, so Home's Needs you and the
dashboard can tell which runs are waiting for an answer. - Home is a home page. The composer leads, and its configuration folds into one Run settings
row that summarises the choices. Runs waiting for you come first. A side rail shows the last
7 days, tools above 20% errors, and whether model providers are answering. web_fetchextracts article text with trafilatura and sends ordinary browser request headers.
It retries timeouts, 429 and 502–504 responses twice, with backoff, honouringRetry-Afterup
to 5 s. On 401/403/404/410/429/451 or a bot-check page it falls back to the Internet Archive's
closest snapshot. That goes through the same SSRF checks and only when the run's domain policy
allows archive.org. Bot checks are reported, never bypassed. Every error says what to do next:
for a 404, for example, search for the real address instead of guessing URLs.knowledge_readfinds a document by id, exact file name, theknowledge base/fileform that
knowledge_searchcites (with or without#chunk), base name, title, or a close match.
Knowledge base names match regardless of case. A miss lists the closest file names.artifact_readaccepts./,/workspace/andworkspace/prefixes, any case, a unique base
name or a close match. A miss lists the workspace's files.- Failed tool calls end with a
Recovery:line when the tool gave no guidance: the schema for bad
arguments, "look it up first" for missing names, the available tools for an unknown tool.
Read-only built-in tools get one automatic retry after a timeout or dropped connection. - The interface: badges and menu labels are in sentence case instead of all caps, status badges
are square instead of pills, and the Insights KPI cards drop their tinted icon circles.
Fixed
- Resuming a run with linked knowledge works. The old run's links are stored as strings and were
compared with the database's UUIDs, so every such resume failed: with "Knowledge base not found"
on Postgres, and an internal error on SQLite. They are normalised now, and a knowledge base deleted
since is left out instead of refusing the resume. - A resumed run gets its whole board back. Before, it rebuilt only the notes written with
notes_write, and lost the step results, reviews and helpers' results posted to the board. - Runs halted before this release resume too.
- Their board is rebuilt from their A2A board posts (or, for older runs still, their
notes_writecalls). - Their saved guardrails take the new settings' defaults.
- A run that failed to resume with "Knowledge base not found" can simply be resumed again.
- Their board is rebuilt from their A2A board posts (or, for older runs still, their
- Claude 5-family turns no longer fail on a stale thinking block.
- On Claude Opus 5.5, Sonnet 5.5, Haiku 5.5 and Fable 5.1, a thinking block is bound to the
conversation that produced it. A council member's prompt carries the live board and its history
is compacted, so for accounts the API enforces (created on or after 2026-08-31), a turn could
fail with "bound to a different conversation". - After the first such 400, the provider retries once with
thinking.block_binding.prefix_mismatch_behavior: "drop_block"(beta
thinking-binding-controls-2026-08-01), and keeps sending it for that provider. Stale blocks
are dropped and the turn goes on. - Accounts that aren't enforced send their requests unchanged.
- On Claude Opus 5.5, Sonnet 5.5, Haiku 5.5 and Fable 5.1, a thinking block is bound to the
- PDF exports no longer fail with
internal_error. Two problems in a row caused it:- A table cell, callout or quote taller than one page made reportlab raise
LayoutErroron
every render attempt. Those rows now split across pages. - The renderer's last fallback, the plain exporter, then crashed on the report's in-page links
(#executive-summaryin the table of contents). Only absolute links (http,https,
mailto) become clickable now, and the others stay as text. - The last fallback can no longer fail; at worst it keeps the words as plain paragraphs. If an
export still cannot be rendered,POST /runs/{id}/exportsanswers422 export_failedwith the
reason, instead of a bare 500.
- A table cell, callout or quote taller than one page made reportlab raise
- Section tabs (Connections, Settings, Insights) no longer show a stray vertical scrollbar at
their right edge.
Full Changelog: v0.1.2...v0.1.3