Making chat the default for every kind of AI work is often a poor design decision.
During a typical workday, I asked Ragbot to find a past design decision, ran a morning routine through my coding agent, and reviewed the day's plan and draft queue in synthesis-console. These activities asked different things of the interface. In one, I needed help forming a question. In another, the steps were already known. In the third, I needed to see the state and make a decision.
That was the arrangement behind my July setup: two tools I had built, plus a procedural executor borrowed from whichever coding agent I was using. My own procedural system, Ragenie, was unfinished. I wanted each part of the setup to suit the work I did there, with shared project records that outlived any one tool.
I think about that movement in three modes: conversation, procedure and direct manipulation. They are choices within a task. A runtime is the software that executes work, and one runtime can support several of these interactions.
Choose the next interaction
Conversation helps me discover what I need. I can ask where a half-remembered lesson lives, follow a citation, question the earlier decision and refine the problem. The exchange is useful when I cannot yet write a complete instruction. It also lets me ask for an explanation after a procedure or visual review reveals something unexpected.
Procedure helps me repeat work whose steps are known. A repository check or a daily planning routine should have defined inputs, actions and expected results. I can save that procedure as a script or a skill: a package of instructions, with supporting files or code when needed. The repeated work then starts from a maintained definition. The definition still needs review when the task or its dependencies change.
Direct manipulation helps me inspect and change visible state. A plan, queue or editable draft puts the object of judgment in front of me. I can compare items, select one, make a change and inspect the result. For that to help, the display must show the information the decision depends on, including dates, unresolved questions and the source of a claimed result.
There is a useful HCI lineage here. In his 1983 paper on direct manipulation, Ben Shneiderman emphasized visible objects and rapid, incremental, reversible actions. Hutchins, Hollan and Norman's 1985 paper distinguished an interface that mediates a conversation about a world from one that represents a world the user can act on.
The same 1985 paper also discusses the limits of direct manipulation. It specifically identifies repetitive operations as candidates for scripts and explains why symbolic descriptions can express things that are awkward to manipulate directly. Procedure was already part of that discussion. My three modes are a working lens for choosing an interaction; the paper does not establish them as an exhaustive taxonomy.
Large language models made conversation far more capable. They also became an engine for procedures and visual interfaces. Collapsing all three into chat confuses the engine with the interface.
Where the interaction gets in the way
A repeated request can drift if I ask an assistant to work out the procedure again each time. The remedy is to retain the steps and their checks. Chat can be the place I invoke that saved procedure. As checked on September 27, 2026, OpenAI's skills documentation describes explicit and implicit use of reusable skills, including optional scripts. A chat interface does not require the plan to be reconstructed from scratch.
A stored workflow also needs a distinction between fixed computation and judgment. A script can repeat a defined calculation; an embedded model may still produce different interpretations or text. For a recurring report, I would put filtering and arithmetic in code and make the interpretation a separate, reviewable step. Calling the whole thing a procedure does not make every result deterministic.
Route visible state through serial prose and every glance becomes a question. Which projects are stale? What went out under my name today? If the answer omits dates and unresolved decisions, I must ask follow-up questions to reconstruct the comparison. A rendered view can put those details together and let me act where I see them. A conversational interface can render that view too; the useful choice is to expose the state I need for judgment.
A tool that answers ambiguity by adding menus can become harder to use with each addition. A workflow engine can demand a completed form before I know what I want. Anyone who has fought an expense system knows the shape. A visual prototype can help me discover the problem; a required form can prevent it.
The tools in my July setup
The synthesis engineering I practice starts with the interaction people need and leaves the model wiring until last. My open-source tools grew around that design choice.
Ragbot was my conversational entry into workspaces of Markdown and YAML. It indexes those repositories, retrieves passages with citations and provides skills alongside conversation. The May source and release notes describe its move beyond retrieval into an agent loop, durable memory and Model Context Protocol support as both client and server. Local and remote model choices are subject to workspace routing policy. Workspace labels and confidentiality controls make intended handling visible. I wrote about the May release arc separately.
My procedural work ran as skills in the coding agent I was using. The procedures were mine; execution also depended on that agent's tools, permissions and environment. Ragenie was the unfinished first-party home for that lane. Its historical repository contains backend services and a LangGraph workflow that retrieves context, augments a prompt and generates a response. Its status table labeled the backend work complete and the React frontend and Ragbot integration not started.
synthesis-console gave me a browsable and searchable view of project indexes, working context, session history, lessons and daily plans. Its file-backed views read the source records when a page loads, so editing the records and refreshing the page does not require an import into a second project database. By the July 8 source snapshot, the console also included draft approve, edit and skip actions, a commitments view and an “On your behalf” digest with links. Available copy and send actions depended on source configuration. A dashboard is a display I glance at; a console is a place I act from.
The digest depends on the plan records: an action missing from them will be missing from the view.
One morning review across the modes
My morning procedural lane included repository synchronization, meeting-transcript retrieval and preparation of the day's plan. In the console, I reviewed that plan, the drafts awaiting judgment and the digest of recorded activity, approving and skipping in minutes. A question about an old decision could send me back to Ragbot and its citations.
Consider a smaller, illustrative review with three invented projects. It separates the work of assembling a view from the decisions the view cannot make.
| Project record | What the review exposes | What remains to do |
|---|---|---|
| Navigation | A recorded link check has a matching evidence file; a decision about task-based versus product-based grouping remains open. | Compare the groupings against reader questions. |
| Batch import | The entry is 26 days old and reports a passed check without an evidence file. | Locate or rerun that check before relying on it. |
| Release notes | A recorded check has a matching evidence file; review of the wording and facts is still pending. | Complete that review before requesting publication. |
Conversation helps with the navigation choice: which reader questions favor each grouping, and what evidence would distinguish them? The link check cannot settle that question. The repeatable procedure gathers entry dates, check references, pending decisions and next actions. The visible review puts those facts together so I can choose where to investigate. An old entry calls for a current check; its age alone does not establish that the project is inactive.
The downloadable review example contains the fictional records, a Python script that produces a JSON report and an HTML view, and a checker with expected results. The offline check confirms that unresolved decisions survive, missing or changed evidence stays visible, and all next actions reach the view. A matching evidence file establishes that its bytes agree with the supplied record; it does not establish the truth of the recorded result.
The routing questions I use are still simple: do I know the steps; do I need visible state to decide; am I still discovering what I want? A single morning review can answer yes to all three at different points.
Which state survives the tools?
The shared files are the architectural reason I can use several runtimes without multiplying every maintenance task. My authored project context, decisions, lessons and plans live in plain-text repositories under version control. Ragbot can index them, the console can render them, and agents can update them.
These authored records make the interfaces disposable. If I retire a runtime, the project's decisions, lessons and unfinished work are still in git, readable without that tool. That is my test of the architecture: would the knowledge survive the products?
There is more state to account for, though. The Ragbot memory migration in the May snapshot defines database tables for entities, relations, session memory and user memory. Those tables could hold information beyond the source documents. Keeping the repositories does not by itself preserve whatever an installation has stored there.
Before retiring or replacing a runtime, I would make this inventory:
| Kind of state | What to retain or establish |
|---|---|
| Authored records | Keep the actual files and their history, including decisions and unfinished work. Confirm the successor can read their structure. |
| Derived retrieval data | Establish which indexes can be rebuilt, from which retained inputs, with which configuration. Test that reconstruction. |
| Unique runtime state | Identify populated memory stores, conversation records and checkpoints. Export or retain what is needed; do not assume it exists in the project files. |
| Configuration and access | Record required settings, tool adapters and dependencies. Re-establish credentials and permissions securely rather than putting secrets into the repository. |
A shared configuration directory reduces duplication, but each consumer still has to interpret the settings it uses. A shared skill format has a similar limit. The Agent Skills specification, checked September 27, 2026, includes environment requirements and notes that support for its allowed-tools field varies among implementations. A skill may need particular tools, packages or network access.
Before depending on the same skill in Ragbot, Claude Code, Codex, Cursor or Gemini CLI, I would check discovery, dependencies, access and outputs in each intended host. Retaining one definition can save maintenance. It does not remove the work of maintaining the executors and their integrations. The cross-tool handoff article describes the receiving checks in more detail.
Choosing for your own work
Choose the durable records first: plain files you own, under version control and readable without a particular product. Then start with a task and the records it must leave behind. If its steps are known, define the procedure and the checks. If the choice depends on relationships among items, build a view that shows those relationships and their evidence. If the problem is still taking shape, use conversation or an exploratory prototype to discover what the procedure and view need to support.
My preference is to attach a purpose-built runtime as each interaction needs one, and let it be good at that work. One product can serve several modes well; I still ask whether it gives me a real choice of interaction or a chat box wearing menus. Can I find the reason for a decision, rerun the known steps, inspect unresolved state and retain the records I need?
I want to carry the same approach into voice and spatial interfaces. Voice can carry a conversation or invoke a known action; a spatial interface can expose relationships for manipulation. When either improves the work, I want it connected to records I own, through a new runtime where that helps. The engine will keep improving on its own schedule. The interface is still a decision, and it is yours to make.