CapChat, the AI assistant

What it does

CAPCAD_CAPBOT opens the CapCad AI window, modeless and single per session: running the command again only brings it to the front. The conversation is cleared when the window is created.

Every click on Go (12) walks this path:

1. The question. Empty, the answer is Type a question first. and nothing happens.
2. The scope. In Selection mode (8) with no fresh selection, the window hides, the command asks for the selection in the drawing and the window comes back. Give up and the answer is Selection cancelled. Try again.
3. The prompt. CapCad assembles the execution contract, adds every installed skill, the selection block (when there is one) and, in write mode, the modification protocol.
4. The generation. The question goes to the API with the model chosen on the Skills tab, inside a conversation window of six messages.
5. The safety net, in write mode only (see Write mode).
6. The execution. The generated .lsp file is loaded into the drawing, with (load …).
7. The wait. CapCad watches the result file for up to 30 seconds. Past that, the answer warns that the command may still be running and suggests a more focused question.
8. The answer appears in box (14), enters the conversation (so the next question can build on it) and the question/prompt/LISP/result set is written to the log.

The AI Answer box therefore shows what the LISP wrote into the result file — not the model's text. When the AI answers in prose instead of code, CapCad wraps that prose in a LISP that simply writes the text into the file, so the path is always the same.

Workflow

A question about the drawing

1. Run CAPCAD_CAPBOT.
2. Write the question in (1), or pick one of the Sample questions (2) — picking one fills the box, and you can edit it before sending.
3. Leave Read-only (4) and All (7).
4. Go (12). The button becomes Thinking... and the progress bar moves.
5. Read the answer in (14). If it is a table, To Excel (15); if it is long text, To Text (16).
6. Ask again: the conversation carries on, and the AI remembers what it answered before.

A question about a stretch

1. Tick Selection (8).
2. Go (12). The window hides and the CAD asks for the selection — or takes the one already made.
3. Select and confirm. The window comes back, showing N entities selected in (10).
4. The question now applies only to those entities.
5. Clear (11) discards the selection; the next question goes back to the whole drawing.

A change to the drawing

1. Tick Read-write (5). The status line (17) turns red.
2. Leave Save dwg before running (6) ticked.
3. Write what you want changed, with numbers: "move entities shorter than 30 up by 10 units".
4. Go (12). Before any change, the confirmation appears with the summary of what will change.
5. Check the summary. Yes applies it; No cancels and the answer is Changes cancelled by the user.
6. Do not like the result: Ctrl+Z.

The form

No screenshot. The numbers below follow the order in which the controls appear: the CAD tab first, top to bottom, then the Skills tab.

CAD tab — the question

CAD tab — mode and scope

CAD tab — run and read

Skills tab

The Skills tab has only that group box. It neither lists nor edits the installed skills, despite the name — see The skills.

The skills

CapCad does not send the question on its own: it sends an execution contract with it and, glued to that, every installed skill — each folder with a SKILL.md file inside Support\ccai\skills\. They are what makes the AI understand a signage project rather than just any dwg.

Three ship with the product:

The two signage skills are written around the sign and marking catalogue of the Brazilian profile: their examples use that catalogue's codes and its Portuguese vocabulary. They still work as a description of how CapCad stores a sign, but a question phrased in your own regulator's codes may need the code spelled out in the question itself.

Adding a skill means creating a folder with a SKILL.md inside skills\. There is no button for it: CapCad simply reads what is in the folder, on every question. Only SKILL.md is read — any other file in a skill folder is ignored. A specific skill never overrides the capcad-core contract.

Write mode

In Read-write mode the prompt gains a protocol, and CapCad gains three checks:

1. The confirmation sentinel. A change is required to begin with a comment line ; ccai-confirm: carrying a specific, quantitative summary of what will change — "I will modify the action attribute on 23 signs (from 'install' to 'keep')", not "Modifying signs". CapCad reads that summary and shows it in a confirmation box before executing. But if the sentinel is missing, the LISP is loaded anyway, with no confirmation and no pre-save — see Notes.
2. The selection lock. If the generated code tries to redefine the list of selected entities that CapCad injected, execution is refused with Generated LISP tries to redefine ccai-input-handles. Execution blocked by safety.
3. The precondition. The protocol requires a change to be verified before it is applied — that a rename's destination name does not already exist, that a deletion counts what it will erase — and forbids partial application: all or nothing. When the check fails, the LISP writes ccai-precondition-failed: and CapCad turns that into the message The operation could not be performed safely: followed by the reason. This one check also runs in read-only mode, because it works on the result rather than on the code.

The first two checks apply in write mode only: a read-only query passes through neither of them.

The selection

Selection (8) does not hold a list of entities in memory: it writes a file, ccai_selection.txt, with the handle and the type of each chosen entity, plus the date, the count and the drawing name.

• The current selection is reused if there is one; otherwise the command asks for a new one.
• The file is valid for 60 minutes. Past that it is ignored as if it did not exist — neither the status (10) nor the prompt sees it.
• While it is valid, the handles are injected into the LISP as a ready-made list, and the prompt tells the AI to work only on them, unless the question explicitly asks for the whole drawing. The handles themselves go into the code, not into the prompt; the prompt carries only the count and the age of the selection.
• Clear (11) deletes the file.

Remembered between sessions

The conversation lives only in memory, holds six messages and is cleared by Reset memory (3) and by any reopening of the window after it has been closed.

On disk, inside Support\ccai\ in CapCad's installation folder, live:

The log is the best place to understand a strange answer: it shows exactly the code that ran on your drawing.

Notes

• It is a beta command, and the window says so itself. The warning at the top asks you to save your work before running and to check the results. Take it seriously: the LISP is written by an AI and runs on your drawing.
• "Read-only" is an instruction, not a lock. The prompt tells the AI not to change the drawing, but in that mode the generated code is loaded without the write-mode checks — neither the sentinel check nor the selection lock applies. A LISP that modified the drawing despite the instruction would run without any confirmation. In practice the model obeys; even so, save first.
• A change without the sentinel escapes the confirmation. The confirmation box — and the pre-run save with it — only appears when the generated code actually carries the ; ccai-confirm: line. Generated code that modifies the drawing and omits the sentinel is loaded straight away.
• The question leaves your machine; so, eventually, does what the drawing answered. The API receives the question, the conversation history, the contract, the text of the skills and — when there is a selection — the number of entities and the age of the selection. The dwg itself, the entities and their coordinates are never uploaded: it is the LISP, running locally, that reads the drawing. But the result of each run is appended to the conversation, and the conversation is sent again with the next question — so whatever the LISP reported (layer names, block names, attribute values, coordinates) does travel on any follow-up question in the same window. Reset memory (3) is what stops that.
• The 30-second limit is on the result, not on the command. Past the limit, CapCad gives up waiting, but the LISP may still be running in the CAD. Look at the command line before asking again.
• The IDs button (9) is not available in this version.
• The Skills tab does not manage skills. Despite the name, it contains only the model choice. The skills are folders on disk.
• The log is only written when the run succeeds. A generation error, an execution error or a 30-second timeout leaves no log entry. Note also that each log file contains the full prompt, and therefore the complete text of every installed skill.
• Part of the window is in English on every profile. The warning at the top, the Model group box, the Go button, the CAD tab and the window title have no translation in any language. All the status and error messages are English too — Read-only mode, Thinking..., Type a question first., Selection cancelled. Try again.
• The CSV answer depends on what the AI wrote. To Excel (15) only works when the answer really is comma-separated; ask for it in the question ("answer in CSV") when you want the table.
• The conversation keeps only the six most recent messages. In a long sequence the beginning is forgotten — and the result of each run counts towards that total. For a new, independent question, Reset memory (3) keeps the old context out of the way.