conjectory

The workbench

A closer look at what Conjectory shows and does. The screenshots come from a small demo project.

The artifact graph

Every file in the project becomes a card on a canvas: notes, claims, evidence, proofs, questions, and prompts, each kind with its own color. Links between files become arrows, so a claim points at the evidence that supports it. Cards of the same kind with the same connections collapse into one stack, which keeps a large project readable. Clicking a card opens it: the text with math rendered, a built-in viewer for PDFs and figures, and the git history of that one file. Badges show who made each artifact: a person, the agent, or both.

The artifact graph with a note open in the inspector, showing rendered math, an open-problems checklist, and the file's git history
The graph, with a note open in the inspector.

The journal

The journal is the project's history, read straight from git. Every branch gets a lane, and forks and merges are drawn as elbows between rows. Each row shows who made the commit, how long the step took, what changed, and what it cost. Work that is not committed yet rides on top as a working row. Selecting a commit lists the files it produced, and each one links back to its card in the graph.

The journal in lanes mode: commit rows with author dots, durations, change counts, and per-step costs
The journal. Dot color marks the author: blue for a person, red for the agent. Steps carry their cost.

Open questions

Notes can hold an "Open problems" checklist. The app collects every checklist into one list for the whole project and keeps score of what is open and what is settled. The agent works from this list too: settling a question is progress, and new results usually add new questions.

The project-wide open questions list, with open and settled items
The question ledger for the demo project.

Mission control

This is where research runs. The goal contract is edited and saved here. A run starts with a chosen model, a cost ceiling, and an optional time limit; a live feed then shows every step the agent takes. The box at the bottom is for steering: ask a question, change the goal, or answer something the agent asked. A small secretary agent reads each message, updates the goal file when needed, and tells the working agent to change course. Progress can be spoken out loud.

Mission control: the goal contract editor, run controls with model and limits, the runtime picker, and the steering box
Mission control, ready to start a run.

How it runs Claude

Conjectory has Anthropic's Claude Agent SDK built in, and it can drive Claude two ways. If Claude Code is installed on the machine, the app uses that install, and runs bill to its subscription. Otherwise, with an ANTHROPIC_API_KEY set, the app uses the runtime bundled inside the SDK and pays per token. The app checks what is available, picks the subscription route when it can, and shows the choice before each run.

The same rules apply either way. The cost ceiling and the time limit are enforced by the app, outside the agent. The working agent and the secretary use the same route. When the subscription route is active, the app removes the API key from that session so the run cannot quietly switch to per-token billing.

Git, handled for you

The app operates the repository by itself. Creating a project makes a git repo. Saving the goal makes a commit. The agent commits every step, with its token count and cost written into the commit message. Forking an approach makes a branch and a separate working folder, with the instructions for that fork saved as its first file. Going back means forking again from an older commit.

Commits made by the agent carry an agent author name, which is how the journal and the graph know who did what. There is no hidden database. Everything is ordinary git, and any git tool can read it.