Most AI tools make you copy text out of a chat window and paste it into the place you actually work. I wanted the opposite: my files open and editable in one window, with the agents working on them right beside me.
Short answer: JoeBro is a free, open-source Mac workspace for your AI agents. Documents and code open next to the conversation, you edit them yourself, and the agents (Claude Code, Codex and OpenCode, plus any model you point it at) read and change the same files. This post is about the design decisions behind the file editing, since "let an AI edit my files" is where most of the risk is.
Why put the editor next to the agent
The editor opens documents beside the chat, so you and the model work on the same text. It handles Markdown with a live outline for jumping around long documents, and it also opens Word .doc and .docx files and spreadsheets. You bind a folder to a workspace, and the agent's file tools (list, read, create, edit) work inside that folder.
How do you stop an agent from editing a file behind your back?
Three rules, in order of how often they matter:
- If the document is open in the editor, an AI edit is held as a pending change. The editor shows it as an Apply/Reject diff, so there is no blocking popup and no timeout. You look at the change and decide. This is the common case and it is the one I care most about: the change is visible where you are already looking.
- If the file is not open, the write can be gated before the file is touched. Where an approval channel exists, the edit waits for an explicit yes. If there is no live channel to ask on, the write is refused rather than silently applied.
- Commands are a separate gate. "Ask before running commands" is the setting that raises a blocking approval for shell and Python tools. Reading and editing documents are a different risk from running a command, so they are separate switches.
Long files and truncated edits
Models rewrite long files badly in one go. Two practical fixes in the file tools:
- Chunked creation. A long document can be created in parts. When the next part arrives, the server joins it to what is already saved, and because tool arguments arrive with trailing newlines trimmed, it adds the missing blank line (a single newline for CSV and spreadsheet-style files) so that two parts don't run together.
- Detecting truncation. If a reply hits its token limit halfway through an edit, the arguments are not valid JSON. If you parse that as an empty dict, the tool fails with a misleading "requires path". The tool layer checks for non-empty, unparseable arguments and treats it as a truncated call instead.
There is also a small alias table for the parameter names that models invent (file, filepath and file_name all mean path; old_string means find), because dropping those calls costs a whole turn.
Why this matters for agents that aren't "chat" models
Claude Code, Codex and OpenCode run in their own terminals. JoeBro shows their sessions in the same window as your files, so you can read what they are doing, answer their permission prompts, and see the files they change, from the Mac or from the iPhone app. They also share one per-project memory over MCP.
What I'd like feedback on
Whether "held as a pending diff when the file is open" is the right default for files that aren't open yet. Today those go through the approval prompt where there is one, and I keep going back and forth on whether to open the file in the editor automatically instead.
JoeBro is GPLv3, free and local first: chats and memory live in a SQLite file, with no account and no telemetry. One-line install (macOS 26+), which also plugs it into Claude Code, Codex and OpenCode:
curl -fsSL https://joebro.pages.dev/install.sh | bash Code: https://github.com/joexk1/JoeBro . Short answers to common questions: https://joebro.pages.dev/faq/

