u/joexk1

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

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

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

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

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 built this because I feel the vast majority of people do not (and cannot) get the most out of AI at all, or at least without handing their sovereignty over to big tech. The good AI tools are locked behind subscriptions and APIs that watch what you do. And most of what is out there is just a chat box. I wanted something that actually works in my files, reads my email, manages my calendar, and remembers who I am between conversations. So I made it.

It is a native macOS app with a tiny Python backend bundled inside. Clone the repo, open the Xcode project, hit Build. That is it. The backend spawns when the app launches and talks to it over localhost. Nothing leaves your machine.
There is a also a .dmg file in the releases section of the github repo for an easier download process.

• Your data is one SQLite file in ~/Library/Application Support/JoeBro/. Back it up with cp.
• No telemetry, no account, no phoning home.
• Pick the model. Local Ollama or any OpenAI-compatible endpoint (DeepSeek, Anthropic, Groq, Gemini, OpenRouter, paste a key and go).
• THEMING!! Custom wallpapers behind the glass UI. Solid colour themes too.

The Full Workspace:

• Chat with live streaming, extended thinking, and real agent mode. Switch models mid-conversation without losing context. Sort into folders. Drag and drop.
• Deep Research that reads many sources and writes a cited report with images, all on your machine.
• Documents opened right beside the chat. Real Word .doc and .docx files, edited in place with full formatting.
  • Edit any doc/code type you could possibly think, with your agent, directly on your disk in JoeBro.
  • Render HTML and SVG in the workspace after editing the code and even open PDFs right there to read with your agent.
• Email over IMAP. Read, compose, reply, forward, triage. The agent handles it with real tools, not guessing.
• Calendar with natural-language quick add ("lunch with Sam Tuesday 1pm"). The agent creates and manages events for you.
• Brain persistent memory that lives in SQLite. Facts, preferences, project context. The agent remembers across sessions.
• Tasks scheduled automations. Morning email summaries, weekly reviews. They run as agents on their own.
• Skills JoeBro learns what you do often and turns it into reusable procedures with confidence scoring. Review, edit, or prune them.
• AI Check paste text, see how AI-written it reads, suspect sentences flagged.

All info (tasks, skills, memories) are stored locally and editable/deletable directly in JoeBro.

Tools tab - bring your own:

• API Tools - point any JSON endpoint at the model. Give it a URL, name, description, optionally an API key and HTTP method. Put {query} in the URL and the model drops user input right in. Search LinkedIn, Crunchbase, GitHub, weather, HackerNews, anything with a URL works. Toggle on and off anytime.
• MCP Servers - Model Context Protocol over stdio. The app launches the server, discovers its tools and lists them, calls them, then kills the process. Stateless. Hard wall clock timeout so a broken server never hangs a turn. The first launch can take a moment if npx has to download, and errors show in red on the row. No zombie children.
• Plugins - folders on disk that ship their own tools and agent logic. Two kinds: Foreground (active tools the model can invoke) and Background (guardrails that shape every turn without being called). The bundled macOS Use plugin controls the Mac through osascript and screencapture. No node modules, no Python packages. Background plugins report themselves in the "Plugins used" line at the bottom of the reply.

The backend is standard library Python. Zero pip install commands. One Xcode project, one Build.

The agent calls API tools, memory, tasks, calendar, and plugins in one conversation. Permission modes (bound folder, read-only, full access) control how much of your files it can touch.

Take control of your own AI and get the most of it without submitting to big tech!!

Full repo: GitHub - joexk1/JoeBro: A native macOS AI workspace that's actually yours — local-first, private, pro-AI and anti-big-tech. Own your assistant, don't rent it. GPLv3. · GitHub

Any and all feedback/questions are appreciated!

I built this because I feel the vast majority of people do not (and cannot) get the most out of AI at all, or at least without handing their sovereignty over to big tech. The good AI tools are locked behind subscriptions and APIs that watch what you do. And most of what is out there is just a chat box. I wanted something that actually works in my files, reads my email, manages my calendar, and remembers who I am between conversations. So I made it.

It is a native macOS app with a tiny Python backend bundled inside. Clone the repo, open the Xcode project, hit Build. That is it. The backend spawns when the app launches and talks to it over localhost. Nothing leaves your machine.
There is a also a .dmg file in the releases section of the github repo for an easier download process.

• Your data is one SQLite file in ~/Library/Application Support/JoeBro/. Back it up with cp.
• No telemetry, no account, no phoning home.
• Pick the model. Local Ollama or any OpenAI-compatible endpoint (DeepSeek, Anthropic, Groq, Gemini, OpenRouter, paste a key and go).
• THEMING!! Custom wallpapers behind the glass UI. Solid colour themes too.

The Full Workspace:

• Chat with live streaming, extended thinking, and real agent mode. Switch models mid-conversation without losing context. Sort into folders. Drag and drop.
• Deep Research that reads many sources and writes a cited report with images, all on your machine.
• Documents opened right beside the chat. Real Word .doc and .docx files, edited in place with full formatting.
  • Edit any doc/code type you could possibly think, with your agent, directly on your disk in JoeBro.
  • Render HTML and SVG in the workspace after editing the code and even open PDFs right there to read with your agent.
• Email over IMAP. Read, compose, reply, forward, triage. The agent handles it with real tools, not guessing.
• Calendar with natural-language quick add ("lunch with Sam Tuesday 1pm"). The agent creates and manages events for you.
• Brain persistent memory that lives in SQLite. Facts, preferences, project context. The agent remembers across sessions.
• Tasks scheduled automations. Morning email summaries, weekly reviews. They run as agents on their own.
• Skills JoeBro learns what you do often and turns it into reusable procedures with confidence scoring. Review, edit, or prune them.
• AI Check paste text, see how AI-written it reads, suspect sentences flagged.

All info (tasks, skills, memories) are stored locally and editable/deletable directly in JoeBro.

Tools tab - bring your own:

• API Tools - point any JSON endpoint at the model. Give it a URL, name, description, optionally an API key and HTTP method. Put {query} in the URL and the model drops user input right in. Search LinkedIn, Crunchbase, GitHub, weather, HackerNews, anything with a URL works. Toggle on and off anytime.
• MCP Servers - Model Context Protocol over stdio. The app launches the server, discovers its tools and lists them, calls them, then kills the process. Stateless. Hard wall clock timeout so a broken server never hangs a turn. The first launch can take a moment if npx has to download, and errors show in red on the row. No zombie children.
• Plugins - folders on disk that ship their own tools and agent logic. Two kinds: Foreground (active tools the model can invoke) and Background (guardrails that shape every turn without being called). The bundled macOS Use plugin controls the Mac through osascript and screencapture. No node modules, no Python packages. Background plugins report themselves in the "Plugins used" line at the bottom of the reply.

The backend is standard library Python. Zero pip install commands. One Xcode project, one Build.

The agent calls API tools, memory, tasks, calendar, and plugins in one conversation. Permission modes (bound folder, read-only, full access) control how much of your files it can touch.

Take control of your own AI and get the most of it without submitting to big tech!!

Full repo: GitHub - joexk1/JoeBro: A native macOS AI workspace that's actually yours — local-first, private, pro-AI and anti-big-tech. Own your assistant, don't rent it. GPLv3. · GitHub

Any and all feedback/questions are appreciated!

I built this because I feel the vast majority of people do not (and cannot) get the most out of AI at all, or at least without handing their sovereignty over to big tech. The good AI tools are locked behind subscriptions and APIs that watch what you do. And most of what is out there is just a chat box. I wanted something that actually works in my files, reads my email, manages my calendar, and remembers who I am between conversations. So I made it.

It is a native macOS app with a tiny Python backend bundled inside. Clone the repo, open the Xcode project, hit Build. That is it. The backend spawns when the app launches and talks to it over localhost. Nothing leaves your machine.
There is a also a .dmg file in the releases section of the github repo for an easier download process.

• Your data is one SQLite file in ~/Library/Application Support/JoeBro/. Back it up with cp.
• No telemetry, no account, no phoning home.
• Pick the model. Local Ollama or any OpenAI-compatible endpoint (DeepSeek, Anthropic, Groq, Gemini, OpenRouter, paste a key and go).
• THEMING!! Custom wallpapers behind the glass UI. Solid colour themes too.

The Full Workspace:

• Chat with live streaming, extended thinking, and real agent mode. Switch models mid-conversation without losing context. Sort into folders. Drag and drop.
• Deep Research that reads many sources and writes a cited report with images, all on your machine.
• Documents opened right beside the chat. Real Word .doc and .docx files, edited in place with full formatting.
  • Edit any doc/code type you could possibly think, with your agent, directly on your disk in JoeBro.
  • Render HTML and SVG in the workspace after editing the code and even open PDFs right there to read with your agent.
• Email over IMAP. Read, compose, reply, forward, triage. The agent handles it with real tools, not guessing.
• Calendar with natural-language quick add ("lunch with Sam Tuesday 1pm"). The agent creates and manages events for you.
• Brain persistent memory that lives in SQLite. Facts, preferences, project context. The agent remembers across sessions.
• Tasks scheduled automations. Morning email summaries, weekly reviews. They run as agents on their own.
• Skills JoeBro learns what you do often and turns it into reusable procedures with confidence scoring. Review, edit, or prune them.
• AI Check paste text, see how AI-written it reads, suspect sentences flagged.

All info (tasks, skills, memories) are stored locally and editable/deletable directly in JoeBro.

Tools tab - bring your own:

• API Tools - point any JSON endpoint at the model. Give it a URL, name, description, optionally an API key and HTTP method. Put {query} in the URL and the model drops user input right in. Search LinkedIn, Crunchbase, GitHub, weather, HackerNews, anything with a URL works. Toggle on and off anytime.
• MCP Servers - Model Context Protocol over stdio. The app launches the server, discovers its tools and lists them, calls them, then kills the process. Stateless. Hard wall clock timeout so a broken server never hangs a turn. The first launch can take a moment if npx has to download, and errors show in red on the row. No zombie children.
• Plugins - folders on disk that ship their own tools and agent logic. Two kinds: Foreground (active tools the model can invoke) and Background (guardrails that shape every turn without being called). The bundled macOS Use plugin controls the Mac through osascript and screencapture. No node modules, no Python packages. Background plugins report themselves in the "Plugins used" line at the bottom of the reply.

The backend is standard library Python. Zero pip install commands. One Xcode project, one Build.

The agent calls API tools, memory, tasks, calendar, and plugins in one conversation. Permission modes (bound folder, read-only, full access) control how much of your files it can touch.

Take control of your own AI and get the most of it without submitting to big tech!!

Full repo: GitHub - joexk1/JoeBro: A native macOS AI workspace that's actually yours — local-first, private, pro-AI and anti-big-tech. Own your assistant, don't rent it. GPLv3. · GitHub

Any and all feedback/questions are appreciated!

I built this because I feel the vast majority of people do not (and cannot) get the most out of AI at all, or at least without handing their sovereignty over to big tech. The good AI tools are locked behind subscriptions and APIs that watch what you do. And most of what is out there is just a chat box. I wanted something that actually works in my files, reads my email, manages my calendar, and remembers who I am between conversations. So I made it.

It is a native macOS app with a tiny Python backend bundled inside. Clone the repo, open the Xcode project, hit Build. That is it. The backend spawns when the app launches and talks to it over localhost. Nothing leaves your machine.
There is a also a .dmg file in the releases section of the github repo for an easier download process.

• Your data is one SQLite file in ~/Library/Application Support/JoeBro/. Back it up with cp.
• No telemetry, no account, no phoning home.
• Pick the model. Local Ollama or any OpenAI-compatible endpoint (DeepSeek, Anthropic, Groq, Gemini, OpenRouter, paste a key and go).
• THEMING!! Custom wallpapers behind the glass UI. Solid colour themes too.

The Full Workspace:

• Chat with live streaming, extended thinking, and real agent mode. Switch models mid-conversation without losing context. Sort into folders. Drag and drop.
• Deep Research that reads many sources and writes a cited report with images, all on your machine.
• Documents opened right beside the chat. Real Word .doc and .docx files, edited in place with full formatting.
  • Edit any doc/code type you could possibly think, with your agent, directly on your disk in JoeBro.
  • Render HTML and SVG in the workspace after editing the code and even open PDFs right there to read with your agent.
• Email over IMAP. Read, compose, reply, forward, triage. The agent handles it with real tools, not guessing.
• Calendar with natural-language quick add ("lunch with Sam Tuesday 1pm"). The agent creates and manages events for you.
• Brain persistent memory that lives in SQLite. Facts, preferences, project context. The agent remembers across sessions.
• Tasks scheduled automations. Morning email summaries, weekly reviews. They run as agents on their own.
• Skills JoeBro learns what you do often and turns it into reusable procedures with confidence scoring. Review, edit, or prune them.
• AI Check paste text, see how AI-written it reads, suspect sentences flagged.

All info (tasks, skills, memories) are stored locally and editable/deletable directly in JoeBro.

Tools tab - bring your own:

• API Tools - point any JSON endpoint at the model. Give it a URL, name, description, optionally an API key and HTTP method. Put {query} in the URL and the model drops user input right in. Search LinkedIn, Crunchbase, GitHub, weather, HackerNews, anything with a URL works. Toggle on and off anytime.
• MCP Servers - Model Context Protocol over stdio. The app launches the server, discovers its tools and lists them, calls them, then kills the process. Stateless. Hard wall clock timeout so a broken server never hangs a turn. The first launch can take a moment if npx has to download, and errors show in red on the row. No zombie children.
• Plugins - folders on disk that ship their own tools and agent logic. Two kinds: Foreground (active tools the model can invoke) and Background (guardrails that shape every turn without being called). The bundled macOS Use plugin controls the Mac through osascript and screencapture. No node modules, no Python packages. Background plugins report themselves in the "Plugins used" line at the bottom of the reply.

The backend is standard library Python. Zero pip install commands. One Xcode project, one Build.

The agent calls API tools, memory, tasks, calendar, and plugins in one conversation. Permission modes (bound folder, read-only, full access) control how much of your files it can touch.

Take control of your own AI and get the most of it without submitting to big tech!!

Full repo: GitHub - joexk1/JoeBro: A native macOS AI workspace that's actually yours — local-first, private, pro-AI and anti-big-tech. Own your assistant, don't rent it. GPLv3. · GitHub

Any and all feedback/questions are appreciated!

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. Clone the repo, open the Xcode project, hit Build. That's it.

FULLY CUSTOMISABLE! SET ANY PIC AS YOUR WALLPAPER!

The new Tools tab has a feature called API Tools. You give it a URL, a name, a description, and optionally an API key and a method. Put `{query}` anywhere in the URL and whatever you type 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. A LinkedIn search when you need a contact. You bring your own API keys and endpoints. The model figures out the rest.

There are two other tiers under the hood. MCP Servers follow the Model Context Protocol over stdio. The app spawns the server, discovers its tools, calls them, then kills the process. No zombie children. Every interaction has a hard wall clock timeout so a broken server never hangs a turn. Plugins are folders on disk that ship their own tools and agent logic. The bundled one controls the Mac through osascript and screencapture directly. No node modules, no Python packages, no Docker.

The agent can call memory, tasks, calendar, custom tools, and plugins in one conversation. It looks like any other chat.

One more thing. You can organise your chats into folders now. Right click a chat in the sidebar, create a new folder, drag chats in and out. Keep side projects separate from work or separate by topic.

The backend is still standard library only. It got split into sibling modules as it grew but there are still zero pip install commands. Still one Xcode project, one Build, and it runs. Still GPLv3, no telemetry, no account, no phoning home.

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

Happy to answer questions.

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. Clone the repo, open the Xcode project, hit Build. That's it.

FULLY CUSTOMISABLE! SET ANY PIC AS YOUR WALLPAPER!

The new Tools tab has a feature called API Tools. You give it a URL, a name, a description, and optionally an API key and a method. Put `{query}` anywhere in the URL and whatever you type 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. A LinkedIn search when you need a contact. You bring your own API keys and endpoints. The model figures out the rest.

There are two other tiers under the hood. MCP Servers follow the Model Context Protocol over stdio. The app spawns the server, discovers its tools, calls them, then kills the process. No zombie children. Every interaction has a hard wall clock timeout so a broken server never hangs a turn. Plugins are folders on disk that ship their own tools and agent logic. The bundled one controls the Mac through osascript and screencapture directly. No node modules, no Python packages, no Docker.

The agent can call memory, tasks, calendar, custom tools, and plugins in one conversation. It looks like any other chat.

One more thing. You can organise your chats into folders now. Right click a chat in the sidebar, create a new folder, drag chats in and out. Keep side projects separate from work or separate by topic.

The backend is still standard library only. It got split into sibling modules as it grew but there are still zero pip install commands. Still one Xcode project, one Build, and it runs. Still GPLv3, no telemetry, no account, no phoning home.

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

Happy to answer questions.

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. Clone the repo, open the Xcode project, hit Build. That's it.

FULLY CUSTOMISABLE! SET ANY PIC AS YOUR WALLPAPER!

The new Tools tab has a feature called API Tools. You give it a URL, a name, a description, and optionally an API key and a method. Put `{query}` anywhere in the URL and whatever you type 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. A LinkedIn search when you need a contact. You bring your own API keys and endpoints. The model figures out the rest.

There are two other tiers under the hood. MCP Servers follow the Model Context Protocol over stdio. The app spawns the server, discovers its tools, calls them, then kills the process. No zombie children. Every interaction has a hard wall clock timeout so a broken server never hangs a turn. Plugins are folders on disk that ship their own tools and agent logic. The bundled one controls the Mac through osascript and screencapture directly. No node modules, no Python packages, no Docker.

The agent can call memory, tasks, calendar, custom tools, and plugins in one conversation. It looks like any other chat.

One more thing. You can organise your chats into folders now. Right click a chat in the sidebar, create a new folder, drag chats in and out. Keep side projects separate from work or separate by topic.

The backend is still standard library only. It got split into sibling modules as it grew but there are still zero pip install commands. Still one Xcode project, one Build, and it runs. Still GPLv3, no telemetry, no account, no phoning home.

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

Happy to answer questions.

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. Clone the repo, open the Xcode project, hit Build. That's it.

FULLY CUSTOMISABLE! SET ANY PIC AS YOUR WALLPAPER!

The new Tools tab has a feature called API Tools. You give it a URL, a name, a description, and optionally an API key and a method. Put `{query}` anywhere in the URL and whatever you type 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. A LinkedIn search when you need a contact. You bring your own API keys and endpoints. The model figures out the rest.

There are two other tiers under the hood. MCP Servers follow the Model Context Protocol over stdio. The app spawns the server, discovers its tools, calls them, then kills the process. No zombie children. Every interaction has a hard wall clock timeout so a broken server never hangs a turn. Plugins are folders on disk that ship their own tools and agent logic. The bundled one controls the Mac through osascript and screencapture directly. No node modules, no Python packages, no Docker.

The agent can call memory, tasks, calendar, custom tools, and plugins in one conversation. It looks like any other chat.

One more thing. You can organise your chats into folders now. Right click a chat in the sidebar, create a new folder, drag chats in and out. Keep side projects separate from work or separate by topic.

The backend is still standard library only. It got split into sibling modules as it grew but there are still zero pip install commands. Still one Xcode project, one Build, and it runs. Still GPLv3, no telemetry, no account, no phoning home.

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

Happy to answer questions.

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.

I've been working on this as a personal project for a while and it has proved very useful. It's called JoeBro, and it's a native macOS app with a bundled backend: one Python file, standard library only, zero third-party packages.

Clone the repo, open the Xcode project, hit Build. That's it. No containers to pull, no compose file, no port forwarding, no reverse proxy. The backend is bundled inside the `.app`, spawned as a child process on launch, and killed on quit. Binds to `127.0.0.1:8765` and is never exposed to the network. (You can host through any backend you please or point the workspace at any link, this is just a default)

- Zero infrastructure. There's nothing to provision or maintain.

- Your data is one SQLite file. Back it up with `cp`.

- No telemetry, no account, no phoning home.

- You pick the model. Point it at a local Ollama or any OpenAI-compatible endpoint.

- THEMING! Use any custom wallpaper you want behind the liquid class UI (built in solid-colour themes too)

Everything stays on your machine. Every agent action is opt-in per session. The whole thing is GPLv3, so forks stay open too.

What's inside: chat with local or cloud models, document editing, IMAP email, calendar, local memory, deep research, and a permission-gated agent with file and shell access. The full local API is on `127.0.0.1:8765` if you want to script against it.

Work directly in your .md, and .doc/x, and just about any other file type you can think of right there with your agent.

Render html and svg directly in the sidebar after working on the code with your agent.

And because the backend is one readable file with no dependencies, you can audit the whole thing in an afternoon. I'd encourage you to.

This is the first time it's been out in the wild. Happy to answer questions.

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

I've been working on this as a personal project for a while and it has proved very useful. It's called JoeBro, and it's a native macOS app with a bundled backend: one Python file, standard library only, zero third-party packages.

Clone the repo, open the Xcode project, hit Build. That's it. No containers to pull, no compose file, no port forwarding, no reverse proxy. The backend is bundled inside the `.app`, spawned as a child process on launch, and killed on quit. Binds to `127.0.0.1:8765` and is never exposed to the network. (You can host through any backend you please or point the workspace at any link, this is just a default)

- Zero infrastructure. There's nothing to provision or maintain.

- Your data is one SQLite file. Back it up with `cp`.

- No telemetry, no account, no phoning home.

- You pick the model. Point it at a local Ollama or any OpenAI-compatible endpoint.

- THEMING! Use any custom wallpaper you want behind the liquid class UI (built in solid-colour themes too)

Everything stays on your machine. Every agent action is opt-in per session. The whole thing is GPLv3, so forks stay open too.

What's inside: chat with local or cloud models, document editing, IMAP email, calendar, local memory, deep research, and a permission-gated agent with file and shell access. The full local API is on `127.0.0.1:8765` if you want to script against it.

Work directly in your .md, and .doc/x, and just about any other file type you can think of right there with your agent.

Render html and svg directly in the sidebar after working on the code with your agent.

And because the backend is one readable file with no dependencies, you can audit the whole thing in an afternoon. I'd encourage you to.

This is the first time it's been out in the wild. Happy to answer questions.

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

I've been working on this alone for a while. It's called JoeBro, and it's a native macOS app with a bundled backend: one Python file, standard library only, zero third-party packages.

Clone the repo, open the Xcode project, hit Build. That's it. No containers to pull, no compose file, no port forwarding, no reverse proxy. The backend is bundled inside the `.app`, spawned as a child process on launch, and killed on quit. Binds to `127.0.0.1:8765` and is never exposed to the network. Docker? Never met her.

Why this fits here:

- Zero infrastructure. There's nothing to provision or maintain.

- Your data is one SQLite file. Back it up with `cp`.

- No telemetry, no account, no phoning home.

- You pick the model. Point it at a local Ollama or any OpenAI-compatible endpoint.

- THEMING! Use any custom wallpaper you want behind the liquid class UI (built in solid-colour themes too)

Everything stays on your machine. Every agent action is opt-in per session. The whole thing is GPLv3, so forks stay open too.

What's inside: chat with local or cloud models, document editing, IMAP email, calendar, local memory, deep research, and a permission-gated agent with file and shell access. The full local API is on `127.0.0.1:8765` if you want to script against it.

Work directly in your .md, and .doc/x, and just about any other file type you can think of right there with your agent.

Render html and svg directly in the sidebar after working on the code with your agent.

And because the backend is one readable file with no dependencies, you can audit the whole thing in an afternoon. I'd encourage you to.

This is the first time it's been out in the wild. Repo in the comments. Happy to answer questions.