r/AIProductivityLab

JoeBro is a native macOS AI workspace that runs entirely on your machine. No cloud, no account, no telemetry, no third-party packages. Stdlib Python backend, memories in a local SQLite file. Nothing leaves your machine.

It builds up a picture of you as you chat: your projects, your preferences, the things you keep returning to. For a while that lived in a list. Auditable and boring; so I rebuilt it as a graph.

It makes you realise just how much big-tech could know about you, and feel even more it's all on your machine!

Every memory is a node. Related memories cluster together, pulled by a physics simulation. Line length is conceptual distance. Node size is how connected a memory is — your biggest nodes are the things your assistant keeps coming back to. Hover any node and the full memory text pops up. Right-click to edit, pin, or delete.

Pruning is more satisfying than it has any right to be.

The whole UI is liquid glass and you set a wallpaper behind it. The graph floats over whatever image you drop in — nodes, lines, hover cards, all of it. If your wallpaper is moody it looks stunning. Redditors who care about their setup will want to screenshot it immediately.

For me, seeing one project dominate the map as a massive hub node was a strange moment. It knows me. Not because someone trained it on my data, but because I *told* it things and it remembered. That's a different feeling entirely.

Stdlib Python, SwiftUI Canvas, hand-rolled force simulation, GPLv3. Fully offline. Point it at Ollama or any OpenAI-compatible endpoint and you're running.

Repo: https://github.com/joexk1/JoeBro

I made a UX friendly software where you can basically create mini apps with prompting or drag and drop. In the demo, I made a wisper flow clone for speech to text. The workflow also has a trigger than can set customInstructions e.g Translate to spanish, translate text to katex or remove fillers.

check it out at stuard.ai

Why Post this?

I want to show a non-coding use case for Pi for others to take ideas from.

Why do this?

I wanted out of the big-3 chat apps. My conversations, prompts, files, and workflow all lived in their interfaces. Switching providers meant starting over.

So:

• Found Pi → discovered pi-web
• Started extending it, using the system to build itself
• It's now different enough that I gave it its own name: Sayl

I'm not a programmer. 

I understand specs, system prompts, agents.md, context management, etc. but the AI wrote basically all of it. There's surely slop in the code, but it runs on my laptop at home and it's been my daily driver ever since.

It goes wherever I go.

• Any device with a browser — full mobile view, installable as a phone app
• My PC's filesystem, reachable from anywhere
• Close the tab mid-task — sessions live in a daemon, the agent keeps working

It's built for general AI work — brainstorming, writing, research, digging into ideas — but it codes too (it built itself).

What's in it:

• Private web search + deep research — self-hosted search, clean page extraction, live research progress and controls
• Prompt library — Markdown prompts, live preview, usage counts, one keystroke to insert
• Search — within a session, or across every conversation I've ever had
• Real file viewers — PDF, DOCX, XLSX, PPTX, Markdown with math + diagrams, images, CSV/JSON — readable from my phone
• Skills library — reusable agent skills: documents, charts, spreadsheets, and more
• Projects & sessions — groups, folders, pins, archive; the AI even names sessions itself
• Embedded terminal + git, right in the browser
• Context Guard — oversized tool output captured to disk instead of flooding the chat
• Usage dashboard — token/context breakdown, search/fetch counters
• Notifications — native OS alerts when a long task finishes, phone included
• Clean-context reviewer — an independent AI reviewer for finished work (code, docs, writing, analysis)
• Hourly encrypted cloud backups

Security: localhost-only bind, reached through an authenticated tunnel. No open ports.

Not public — just showing what's possible when you point Pi at itself.

Happy to answer questions.

Hey guys,

A couple months ago I built a software that helped me with my AI prompts (which I was horrible at). It ended up helping me a lot, so I decided to give it a name and ship it to whoever wanted to use it. I personally found it very useful, but we have yet to get any users. I was curious if its something that people would pay for or not. honeprompt.com is the site if you want to take a look.

Honest advice is encouraged 🙏🏼

I built JoeBro, a native macOS AI workspace that bundles its own Python backend inside the `.app` file. Standard library only. Zero third-party packages. You can grab it from the .dmg in the repo releases, or clone the repo, open the Xcode project, and hit Build. Either way works.

The new Tools tab has three tiers, all surfaced to the model in Agent mode as callable functions.

API Tools give any JSON endpoint straight to the model. You give it a URL, a name, a description, and optionally an API key and a method. Put `{query}` anywhere in the URL and the model input gets dropped in right there. The description tells the model when to call it. A weather API gets called when someone asks about the weather. A HackerNews search when the topic is tech. It just works.

MCP Servers are the Model Context Protocol over stdio. The app launches the server, discovers its tools, and offers them to the model. The connection is stateless. Spawn, initialize, call, kill. No long-running processes. No zombie children. There is a hard wall clock timeout on every interaction so a broken server never hangs a turn. The git MCP server returns real diffs. The model calls it, the server spawns, it runs, it dies, the diff comes back.

Plugins are the third tier. They are folders on disk that can ship their own tools, memory, and agent logic. They can be foreground (active tools the model can invoke) or background (guardrails that shape every turn). The bundled one is the macOS Use plugin. Dependency free. It controls the Mac through osascript and screencapture. No node module, no Python package, no Docker image. It calls System Events directly and the model can use it to open apps, click buttons, and take screenshots.

The agent calls memory, tasks, calendar, and plugins in one conversation. Looks like any other chat.

Search any public database right in chat. LinkedIn, Crunchbase, GitHub, you name it. Point API Tools at any JSON endpoint and the model calls it like a native function. No curated list — anything with a URL works.

Chats themselves can now be sorted into folders. Keep your side projects separate from work, or separate by topic. Just drag and drop.

The backend is still zero dependencies. But, based on some great advice from people on here, it is not one file anymore though. It grew to the point where that stopped making sense. So I split it into sibling modules. `jb_core.py` is the shared library. `jb_tools.py` handles every tool path including the custom ones. `jb_chat.py` has the agent loop. `jb_assistant.py` has memory, skills, tasks, and deep research. `jb_email.py`, `jb_calendar.py`, `jb_docs.py`, `jb_files.py`, `jb_models.py`. Still standard library only. Still zero pip install commands. Still one Xcode project, one Build, and it runs.

The tool dispatch in `jb_tools.py` routes every path in one place. Native function calls, XML tool blocks, custom API tools, MCP servers, plugins, macOS use. It is all there. The MCP client is stateless with a background reader thread so a hanging subprocess can never block a request. Every server interaction has a hard deadline. If it does not reply in time, the process gets killed and reaped and the turn continues.

Full repo: https://github.com/joexk1/JoeBro

Still open source. Still GPLv3. Still no telemetry, no account, no phoning home.