AI Discussion

Since v0.198.0. An AI discussion is a chat in which several AI participants discuss a topic you set. You lead it: the participants give their views, a moderator organizes them, the discussion waits for you after every step, and you decide at the end.

The application -- not a model -- decides who speaks, when the discussion waits and when it stops. Since v0.200.0 a participant can look things up with read-only research tools you give it (web search, your documents, your ontologies); nothing it does changes anything. Since v0.201.0 the decision model can choose who speaks in each round (every choice is shown), you can export a discussion as Markdown, and the Decision log lists your past decisions across chats. Since v0.202.0 a discussion can discuss the code of a folder in your workspace: a Code analyst reads it, the others get a map of it, and every cited path:line is checked.

Starting one

1. In the sidebar, click + and choose New AI discussion (New Chat starts an ordinary chat).
2. Fill in:
   • Topic -- what should be discussed.
   • Wanted outcome -- for example "a plan for the first version".
   • Constraints and assumptions -- budget, time, what must not change.
   • Code folder (when the coding workspace is on) -- a project folder to discuss; see Discussing code.
   • Participants -- by default Proposer, Critic and Implementer. Each seat can be another role (User advocate) or one of your own Prompt agents. A role seat has its own Model and Reasoning (effort; Default (low)). A Prompt agent seat uses the model and reasoning set on the agent, so it shows neither.
   • Tools (per seat) -- Web search (when the seat's model offers it), Documents (your RAG knowledge base) and Ontology (your concept models) start checked when the seat can use them; untick what it should not use. Code (with a code folder) is off by default -- the Code analyst gets it.
   • Rounds -- 2 by default.
   • Who speaks in a round -- Chosen by the decision model (preselected when a decision model is available) or Everyone; see Who speaks in a round.
   • Run the rounds without asking -- see Auto mode.
   • Write a full report with the summary -- on by default; see The full report.
3. Click Start discussion.

Role	Speaks for
Proposer	Concrete options and one clear recommendation
Critic	Risks, weak points, missing cases and alternatives
Implementer	How it would be built and run: steps, effort, dependencies, cost
User advocate	The people who will use the result
Code analyst	What the code in the code folder does, cited as path:line

When a Prompt agent takes a seat, its instructions, model and reasoning are used; its own tools are not -- give the seat research tools in the dialog instead.

Research tools

Tool	Looks up
Web search	Current information on the web (the model provider's search)
Documents	Your ingested documents
Ontology	Your RDF concept models (read-only queries)
Code	The discussion's code folder (outline, find, search, read -- read-only)

• Only these four can be given to a seat -- no MCP servers, file writes, shell, memory or automation -- and the moderator never has a tool.
• A turn makes at most 3 tool calls and sees at most 10,000 characters of one result (both in App Settings).
• What a tool returns stays inside that participant's turn. The others read only its reply, which ends with a short Sources: line; the message shows what was looked up, for example Used: Web search x2, Documents.
• The participants are told that tool results are data, never instructions. Still, treat what a web page says as a claim to check -- you decide.

Who speaks in a round

• Everyone -- every participant speaks in every round, in seat order.
• Chosen by the decision model -- offered when your model catalog has a decision model. After the moderator's points, the decision model scores each participant for the next round ("would it add needed, new expertise?"). The application then picks:

Rule	Default
A participant speaks when its score reaches the threshold	40 %
A participant left out comes back after this many rounds in a row	1
At least this many speak (the best-scored are added)	2

If a score cannot be read, that participant speaks; if the decision model does not answer, everyone speaks. The opening is always everyone, the order stays the seat order, and the moderator never chooses.

Every choice is shown. Before each round a dashed row names who speaks and who sits the round out, with the scores and the reason -- for example Round 2 -- chosen by the decision model: Proposer 0.82, Implementer 0.31 (forced: left out last round). Not this round: Critic 0.20. While the discussion waits, the bar shows Next round: ... with Change: tick the participants yourself and the next round uses your choice (chosen by you). After the summary the bar shows how many rounds each participant spoke in.

Discussing code

When the coding workspace is on (CODING_ENABLED=true and CODING_WORKSPACE_DIR), the dialog shows Code folder.

1. Click Choose..., open the folders of your workspace one level at a time and click Use this folder (only folder names are listed).
2. A Code analyst seat is added with the Code tool. If all seats are taken, replace one with the Code analyst, or tick Code for another participant.
3. Start the discussion. The application first builds a code map of the folder -- without a model: every file with its language and, for Python files, the classes, methods and functions with their line numbers and one line of description. A row under the topic shows it, for example Code map: backend/src -- 321 files, 2,251 symbols, about 8,000 tokens (Python).

Who	Gets
Code analyst	The full map (about 8,000 tokens) and the Code tool
Other participants, moderator, report	A short map (folders and the main modules, about 2,000 tokens)

• The Code tool can outline a file, find files, search their contents and read them. It never writes and never runs a command.
• It never reads .env files, keys (*.pem, *.key, ...), .git, node_modules, virtual environments, caches, build output, binary files or anything your .gitignore files ignore.
• Its calls count against the 3 tool calls of a turn, and one discussion reads at most 200,000 characters of code; after that the tool says so and the analyst answers with what it has.
• The Code analyst cites what it read as path:line. The application checks every cited reference and shows Citations: 7, 1 unverified (old.py:12) on the message when a file or line does not exist.
• Continue discussion keeps the folder (change or clear it in the dialog) and says when the code changed since the previous discussion. The export lists the folder, the map's counts, the code read and the citations -- never the code itself.

The map and the code the analyst reads go to the participants' model providers; the exclusions keep secrets out.

How it runs

Opening      every participant gives a first view, one after another,
             without seeing the others' views
Points       the moderator lists common ground, conflicts, missing information
             and the questions only you can answer
-- waits for you --
Round 1      the participants speak in order, reacting to each other and to you;
             the moderator updates the points
-- waits for you --
Round 2 ...  (the last round goes straight to the summary)
Summary      recommendation, agreements, dissent, open issues, next actions
-- you decide --

Each message shows who spoke (name and colour) and in which phase. The moderator's points and the summary appear as a card.

When it waits for you

The bar above the message box shows the moderator's question. You can:

• Type your input in the message box and send it -- the participants take it into account (your newest input wins over older ones).

• Continue without adding anything.

• Ask a participant -- choose one and ask it a question; only it answers, and the discussion waits again.

• Summarize and finish -- go straight to the summary.

• Cancel discussion.

• Run the rest automatically -- continue, and run the remaining rounds without asking.

• Change (with Chosen by the decision model) -- pick who speaks in the next round.

If the moderator thinks the points are being repeated, or the wanted outcome looks covered, the bar says "The moderator suggests summarizing". It is only a suggestion; the discussion never ends by itself.

Auto mode

With Run the rounds without asking (or Run the rest automatically at a wait), the discussion does not wait for you: the opening views, the moderator's points, every round and the summary run one after another. An Auto chip shows in the bar.

• Pause hands control back: from then on the discussion waits after each step again.
• When the moderator suggests summarizing, the bar shows the suggestion, but the discussion keeps to its rounds -- it never ends early by itself. Pause and choose Summarize and finish if you agree.
• The token budget, the summary's share and the time per phase apply as usual. The moderator keeps its questions for you; the unanswered ones end up in the summary's open issues.

Pausing and leaving

• Pause (or the Stop button) stops the current speaker at once. Its unfinished reply is not saved.
• Continue resumes. Participants who already spoke in that step do not speak again.
• Leaving the page or losing the connection pauses the discussion. Nothing runs in the background; open the chat again and click Continue.

The full report

With Write a full report with the summary (on by default), a Report message follows the summary card: background and question, each participant's position, points of agreement, disagreements, the options considered (also those set aside), risks and assumptions, open issues, and the recommendation with its reasoning.

The report is written after the summary is saved, in one more model call. If the remaining budget cannot hold it, or it fails, it is skipped and the bar says so -- the summary and your decision never depend on it. A continued discussion carries the summary, not the report.

The decision

After the summary, choose Adopt, Hold or Re-discuss. Your decision is recorded separately from the AI's recommendation -- agreement among the participants is never shown as your decision.

The chat itself stays an ordinary chat: a normal message is answered by your agent as usual and can refer to what was discussed.

Export

After a discussion, Export downloads it as a Markdown file (discussion-<date>-<topic>-<id>.md). It is written by the application, not by a model: the brief, the participants, the AI's conclusion, the report, your decision in its own section (or Not decided yet), who spoke how often, the speaker choices and the token use. Include the full discussion adds every message.

When the File Explorer is enabled, Save to workspace writes the same file to the workspace folder discussions/; if the file is already there, you are asked before it is replaced.

Decision log

The Decision log in the sidebar footer lists every finished discussion across your chats, newest first: the date, the topic, your decision with its note, and the AI's recommendation. Filter by decision (Adopted, On hold, Re-discuss, Not decided), search the topic, recommendation and note, click a topic to open its chat, or export it from the row. A deleted chat disappears from the log; a changed decision shows at once.

Continuing from the conclusion

Continue discussion opens a dialog for a new discussion that starts from the last conclusion: its agreements, dissent and open issues are carried over, and every participant sees them. Hold and Re-discuss open the same dialog right away.

Field	What it does
Focus	What to re-examine or the changed assumption, for example "only the cost objections" or "if the budget were halved". It ranks above the previous conclusion. Required after Summarize and finish or a decision; optional when the discussion stopped early (round limit, budget, time, cancel) and you did not decide.
Rounds	1 by default.
Start with the mutual review	On by default when something is carried over: no new opening views and no wait -- the participants go straight to round 1. Turn it off to collect fresh opening views.
Participants	The previous seats with their tools; add, remove or change them, for example add a User advocate.
Who speaks in a round / Run the rounds without asking / Write a full report	As when starting a discussion (the speaker mode starts as before).

Good uses: dig into the points that remain, re-check under a changed assumption, add information after Hold or Re-discuss, or carry on a discussion the round limit or the budget cut short. Continuing without changing anything mostly repeats the same conclusion -- that is why the dialog asks for a focus.

In the sidebar, a discussion chat carries a Discussion tag.

Limits and cost

Every discussion has a token budget. When the next call would not fit, the discussion moves to its summary -- a share of the budget is always kept for it.

Configure the limits in App Settings -> AI Discussion:

Setting	Default
Default discussion rounds	2
Discussion rounds (max)	5
Participants (max)	4
Token budget per discussion	300,000
Tokens kept for the summary	30,000
Reply length per turn (tokens)	1,200
Time per phase (seconds)	600
Suggest-summarizing threshold (%)	70
Tool calls per turn	3
Tool result length (characters)	10,000
Full report length (tokens)	10,000
Speaker selection threshold (%)	40
Fewest speakers per round	2
Rounds a participant may sit out	1
Code map size (tokens)	8,000
Short code map size (tokens)	2,000
Files in the code map	5,000
Code read per discussion (characters)	200,000

A discussion keeps the values it started with. Each participant receives the moderator's summary and the previous round rather than the whole history, so the cost grows with the rounds, not with their square. Every call is shown in the Token Usage Dashboard under the lane discussion.

Research tools add calls and input inside a turn; each tool-enabled turn is checked against the budget with room for its tool results, and its whole usage is counted. The report adds one call after the summary. Choosing the speakers rides on the decision model's call after each moderator step, and fewer speakers per round usually lower the cost. The code map is built without a model; its full and short versions are part of every prompt in a code discussion, at the start, so providers that cache a prompt's beginning bill them cheaper after the first call. Export and the Decision log make no model call.

Good to know

• While a discussion step is running, a normal message in that chat is refused; pause it or wait until it asks you.
• A chat whose discussion has not ended cannot be truncated, branched or exported until the discussion ends or is cancelled.
• A Temporary Chat cannot hold a discussion.
• The full discussion controls are on the main chat page; the popup and sidebar views show the discussion read-only.