A local workspace for reusable agents and coding, with separate working copies, visible context, reviewable outputs and a deliberate way to continue after interruption.
In practiceAn interrupted document task resumed with a corrected event date, then preserved the file on a further resume—a supervised test of recoverable work.
A saved helper keeps its instructions; every new run starts with a separate workspace. This September 2026 view shows the real agent library.
About this image
Real Prism application; dated development capture · 12 September 2026 Revision: Development capture, 12 September 2026; source commit not recorded
The problem
Running a local model is only the beginning. Useful agent work also needs clear file access, recoverable progress, reliable handoffs and a way to tell a plausible response from a verified result.
What I built
I built a local agent workspace for notes, documents, data and code. It combines reusable helpers, isolated inputs, local inference, run history, output review and an optional connection to Continuum project memory.
The interesting part
PRISM makes the boundary around a task visible: what the agent was given, what it left out, what its tools actually did and what still needs review.
My contribution
Project creator responsible for the local agent workflow, workspace boundaries, output review and recovery design.
Evidence
Real interface captures and local tests cover document and data tasks, preserved inputs, complete downloads and continuation after restart. Broader model reliability is still being improved.
Access
The source code is private. There is no public download or hosted demo.
My decisions & how it was built +
What I own
I design the interfaces and local controller that isolate inputs, record actions and let a person inspect, correct and continue an agent’s work.
A decision I made
I kept stale model summaries in run history but excluded them from resumed prompts when human directions are active, giving the correction priority.
What it builds on
A pinned Codex engine and local models provide agent execution and inference. PRISM adds the controller, workspace boundaries, review and recovery using Node.js, SQLite and macOS sandboxing.
01 / The work
A helper you can inspect and interrupt.
A useful helper needs somewhere safe to work.
PRISM began with a bounded coding workflow and expanded into reusable notes, document, data and custom helpers. A saved helper provides instructions; each new run records that version and starts with a separate workspace.
For folder-based work, the app takes a bounded copy of the inputs and records exclusions. The originals stay outside the worker’s access. A user can choose analysis-only access or allow files to be written in the copy, then inspect and download the results.
Missing context should be visible.
A model cannot receive every file in full. PRISM ranks relevant text excerpts and shows whether each file was supplied completely, supplied partly or omitted. The record includes line ranges and reasons, while the full copied files remain available to bounded tools.
That distinction matters for data work. A few selected rows cannot establish a total for an entire CSV. The acceptance cases checked that the worker calculated from complete inputs, that downloads matched the outputs and that both the original and copied inputs stayed unchanged.
The continuation panel makes the next attempt explicit: review the record, correct the brief, then resume. The original conversation remains saved.
About this image
Real Prism application; dated development capture · 27 September 2026 Revision: Development capture, 27 September 2026; source commit not recorded
A correction must outrank an old summary.
An interruption test exposed a subtle recovery failure. The agent’s saved progress had confused the current date with an event date. Even after a person supplied the correct date in a continuation brief, the resumed model repeated the earlier mistake.
Reordering the prompt did not solve it. The final design keeps stale model summaries in the visible history but excludes them from the resumed prompt when human directions are active. The same failed run then produced the corrected document; another resume preserved it unchanged.
Let project knowledge outlast a run.
A helper can optionally connect to selected Continuum Knowledge pages. Every run and resume fetches them again, recording their versions and any truncation. The controller holds the credentials; the worker does not receive them.
Saving useful findings is a separate review step. The user curates an addition, reviews its destination and then publishes it. A changed page requires a fresh review. If the response is lost, PRISM checks whether the exact addition arrived instead of blindly sending it again.
Continuum holds the durable project knowledge. PRISM keeps the operational record of definitions, attempts, tool actions and pending operations needed to recover the local work.
Useful with a person in the loop.
The continuation release was tested on real notes, document and CSV tasks with a person supervising. Outputs and downloads were checked against the supplied facts and independently calculated totals, and the inputs stayed unchanged. One larger data task still needed a corrective instruction.
The useful result is a workflow you can inspect and steer. PRISM is not yet reliable enough to leave alone on arbitrary work: model accuracy, dependable coding and larger conversations still need improvement. Source selection and result review keep those limits visible.
How it connects
Two kinds of memory, with a clear boundary.
A run needs operational history; a project needs reviewed knowledge. PRISM keeps those roles separate.
01
Local run
Work in a separate copy with a recorded agent definition and model source.
02
Review
Inspect outputs and curate the useful facts or decisions.
03
Continuum
Publish the reviewed addition to a selected project page.
04
Next run
Fetch the current page again before starting.
Connecting project memory is optional. Conversation history is not published automatically.Diagram source
Implemented selected-page memory workflow · reviewed 6 October 2026 Source revision: Product model reviewed 6 October 2026
03 / Choices & trade-offs
The decisions that shaped it.
01
Work on a copy
The original folder stays outside the worker’s access. Coding changes pass through an explicit review and selected-file apply step, with checks for newer local changes and recovery backups.
02
Keep inference local
A local controller pins the chosen model source for each attempt. Changing the inference source does not move command execution to that machine.
03
Preserve actions as well as prose
The controller records completed, failed and uncertain tool actions separately from the model’s own progress notes, so a resumed run can inspect what happened.
04
Respect occupied machines
Source pauses persist and require manual resume. Waiting work remains visible, and restarting the controller does not replay interrupted tasks automatically.
04 / Iteration
What changed along the way.
Coding
From request to reviewable change
The first workflow added isolated source copies, original test baselines, candidate verification, review, selected-file apply and restore.
Reusable agents
Make notes, documents and data first-class
Saved helpers introduced fresh non-Git workspaces, read-only access, preserved run settings and output previews and downloads.
Project memory
Connect reviewed findings to Continuum
Selected-page reads and an explicit review-and-publish flow added durable project memory without giving workers direct access to credentials.
Continuation
Make interrupted work understandable
Visible file-selection records, editable human briefs and durable action history made resuming a deliberate part of the product.
05 / Under the hood
For the curious.
Architecture, implementation and the details behind the interface.
Small local controller+
Node.js built-ins provide the HTTP interface, filesystem handling and SQLite run journal. The installed runtime carries a pinned Codex engine.
Enforced workspace access+
macOS sandbox rules constrain filesystem and network access. Independent checks run against a frozen candidate with network access disabled.
Recoverable operations+
Version checks protect edits, and durable journals distinguish completed work from uncertain apply, restore or memory-publication outcomes.
Dated verification+
The 27 September 2026 continuation release passed 261 native tests. Two installed-app runs processed 1,500 CSV rows each with checked totals, matching downloads and unchanged inputs. One required corrective steering; this is evidence for the tested workflow, not a general accuracy claim.
06 / Current state
Where it stands.
What exists today
PRISM is a private local prototype. It runs with local models and does not silently switch to a hosted service.
Where I’m taking it
Improve local models across ordinary coding and non-coding work.
Test larger conversations, context budgeting and interruption patterns.
Strengthen resource containment before expanding unattended or scheduled work.
