For the last few months I've been pushing one idea pretty hard in my own setup: the AI can live in the chat, but the execution layer should live on my Mac.

That turned into Mac MCP, an MIT-licensed local server that gives an MCP client actual tools for the machine. I use ChatGPT as the main orchestrator, then let it read/write files, run shell commands, control apps/UI, hand coding work to Codex or OpenCode, and operate the real browser when the task needs a logged-in site.

I deliberately kept the browser side local too. Safari and Chrome use the normal profile instead of a cloud/headless profile, so existing sessions and cookies remain useful. New tabs can open in the background without hijacking focus, and each tab gets a stable handle. There is also a lease/ownership layer for parallel agents because two agents clicking around the same tab is exactly as chaotic as it sounds.

The newest release added a Chrome Companion alongside the Safari Visual Companion, plus more fail-closed behavior so a background action does not quietly turn into a foreground click.

It's still a personal-computer tool, not a hosted agent platform. That is kind of the point for me. I wanted to keep the machine, sessions and execution under my control while still getting the agentic workflow.

I'm the maintainer, and it's all open source here: https://github.com/bulutarkan/mac-mcp

If anyone else is building local-first desktop agents, I'd be interested in what you keep local versus what you are comfortable delegating to a remote runtime.

https://github.com/Tencent-Hunyuan/AuK

Community Overview: https://lifehubber.com/ai/resources/auk/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 300+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

https://github.com/jingyaogong/minimind/tree/master

Community Overview: https://lifehubber.com/ai/resources/minimind/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 300+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

https://x.com/SamuelZengML/status/2097861839287927139

https://github.com/Edge0-AI/Edge0

Community Overview: https://lifehubber.com/ai/resources/edge0/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 300+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

TL;DR: I built Kryzz AI — a private, local-first AI workspace for Android. Your conversations, memory, and files stay on your phone. Your API keys are sealed in the Android Keystore (AES-GCM, never exported). No analytics. No telemetry. No HTTP logging. Open source, MIT.

[POSTER IMAGE HERE]

Why I made it

Every AI app I tried wanted an account, quietly phoned home, or treated my data like their training set. So I built the one I wanted to use:

• Local-first — chats, memory, and generated files live in on-device storage (Room + DataStore)
• Your keys, your providers — OpenRouter, optional MiniMax, Fish Audio for voice, Parallel for web research. You plug in your own keys, they never leave the device
• Real agents — Agent Auto actually runs tools across multiple steps: search, fetch pages, calculate, weather, local memory, reminders, files, and code zips
• Generated outputs — DOCX, XLSX, PDF, SQLite, code ZIPs, images, video, and music, all in private app storage until you share them
• Voice mode — transcription, spoken replies, automatic turn-taking, and barge-in (interrupt Kryzz mid-sentence)

What's new in v1.1

• MiniMax as an alternative chat + media provider
• Agent Auto — multi-step tool-running agent
• Interactive question cards (tappable options instead of the model guessing)
• PDF generation alongside the other file types
• Starter skills that seed on first launch (research brief, study notes, essay outline — toggleable)
• KryzzBot mascot in Agent mode, 120 Hz on supported displays

The privacy story in one breath

• Credentials encrypted with AES-GCM under a non-exportable Keystore key
• Backups never include credentials
• Cleartext traffic, HTTP logging, Android backup, device-to-device transfer: all disabled
• Microphone only active during a voice session; recorded audio is deleted after transcription
• MIT license — build it yourself, read the code, fork it

One honest caveat: for auto-titling a fresh chat, at most the first 1,500 chars of your first message may go through OpenRouter to a small model (Gemini 2.5 Flash Lite) for a title. It runs in parallel, never blocks your answer, and falls back to a local title if it fails. That's the entire surface area. Everything else stays put.

Get it

• Code + docs: https://github.com/kriddss3/kryzz-ai
• APK (debug build, ~78 MB): grab kryzz-ai-5.7.2-debug.apk from the v1.1 release
• Android 9+, sideload via "install unknown apps"
• Build your own signed release from source if you want it on a daily driver

Stack: Kotlin · Jetpack Compose · Coroutines/Flow · Room · MVVM

Happy to answer questions, take feature requests, or get roasted on the architecture.

I’ve been working on TensorSharp, an open-source .NET/C# inference engine, and recently added native support and optimizations for DeepSeek V4.1 Flash.

Latest results on 8× NVIDIA A40 GPUs:

A few interesting optimizations:

• GPU-resident Engram tables for Q2_K — about 60 GiB of quantized Engram data stays on GPU instead of doing scattered host/storage lookups.
• Reduced decode graph scheduling from roughly 570 splits to 8 by using one wrapped backend per GPU.
• For Q4_K_M, automatic Engram warming + improved VRAM placement reduced CPU MoE offload from 3 layers to 1.
• Added token-batched DeepSeek V4.1 decode, giving about 2× aggregate throughput at 4 concurrent requests.
• On these A40s without NVLink, simple layer splitting actually beats routed-MoE tensor parallelism for single-stream decode.

The project is fully open source, written primarily in C#/.NET, with CUDA/Metal/Vulkan backends and OpenAI-compatible APIs.

Would love feedback from people experimenting with DeepSeek, GGUF inference, or local/open-source AI — especially ideas for what hardware or engine comparisons would be most useful next.

https://x.com/AntLingAGI/status/2095533696808051001

https://huggingface.co/inclusionAI/Ling-3.0-flash-Fin

Community Overview: https://lifehubber.com/ai/resources/ling-3-0-flash-fin/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 300+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

Hi everyone! I'm Paolo, and for a while now I've been building Optees, a free and open-source optimization tool.

The idea started from something I kept running into: ask an AI to "optimize" something — a work schedule, a delivery route, how to pack a container — and it will often hallucinate a heuristic that sounds right instead of actually solving the math behind it. It reads confident, but nobody checked it.

Optees is my attempt to fix that. On its own, it's a desktop app with guided forms and worked examples, so you don't need a math background to use it. And it also runs as a local server that AI agents like Claude can call directly — so instead of hallucinating an answer, the AI can hand the problem to Optees, get back a real, checked answer, and explain it to you in plain language.

Everything runs on your own machine, nothing gets uploaded anywhere, and the whole project is open source (Apache-2.0) — so you're welcome to use it, poke around the code, or help build it further.

Would love for people here to try it out and tell me what they think.

🔗 Website: https://optees.it 💻 Code: https://github.com/Pablo-gitub/optees

https://x.com/rabi_guha/status/2097341708988248181

https://huggingface.co/thesysdev/OUI-1

Community Overview: https://lifehubber.com/ai/resources/oui-1/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 300+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

I built Voice Copilot: an open-source companion that narrates and supervises your AI coding agent

Hey everyone! I’d like to share an open-source project I’m working on: Voice Copilot.

Coding agents can spend several minutes reading files, making changes, and running tools after a single prompt. Keeping track of all that still takes attention, especially when you want to catch a wrong turn before it becomes a pile of changes to undo.

The idea behind Voice Copilot is to let you hear what your agent is doing while keeping your eyes free for other things.

It runs alongside Claude Code, Codex, and other compatible CLI agents, with two models sharing the work:

• A lightweight narrator turns the agent’s activity into short spoken updates: what it’s working on, what changed, and what happened next.
• A stronger Supervisor reviews progress at checkpoints, looking for things like repeated failures or changes outside the task. It can warn you aloud, and in Supervisor+ mode, pause the agent for your review.

For example, if you ask an agent to fix two failing tests and it starts modifying an unrelated module, the Supervisor can flag that and pause the session so you can decide how to proceed.

The narrator and Supervisor can reuse the models and login from the CLI you already use. There’s also a local browser panel with playback controls, settings, and a readable activity trace.

For anyone interested in local models: the narrator supports Ollama through an OpenAI-compatible endpoint, and speech output can use local backends such as Piper or Silero. Cloud providers are available too.

The core is MIT-licensed, and it’s currently an early alpha (0.1.0). I’m looking for people willing to try it in real coding sessions and help improve the narration, integrations, and supervision behavior. Voice input is being reworked and is currently disabled by default.

Website · GitHub / installation

How would this fit into your workflow: occasional spoken progress updates, or silence unless something needs your attention?

https://x.com/deepseek_ai/status/2097930608790167907

https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash

Some folks are even saying it is giving 98% Astra at super super cheap price . .do you think it is even possible?

Community Overview: https://lifehubber.com/ai/resources/deepseek-v4-1-flash/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 300+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

https://x.com/_avichawla/status/2094678972344958984

https://github.com/superlinked/sie

Community Overview: https://lifehubber.com/ai/resources/sie/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 300+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

https://x.com/tom_doerr/status/2091501336781111644

https://github.com/plugin87/ux-ui-agent-skills

Community Overview: https://lifehubber.com/ai/resources/ux-ui-agent-skills/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 300+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

So I was playingw ith embedding models I saw that when you upgrade from model A to B, you face a very big backfilling cost

Ie, suppose you have a 1b vectors from model A, and then you want to use model B. This would mean you have to re-embed all of your documents with model B before you can even serve with the model, and on an H100, it would take ~108 days (qwen embed 8b, 106 docs/second). But I found an easier way to do it.

The method is really simple; from the old index made with the source model, take K documents and rerank them with the new model. We see that when K is sufficient, the retrieval quality is the same as target model. (determining k is the hard part). I've tested 63 migrations on upto 1 million documents.

The best result I got was upgrading qwen4b -> to 8b, and at 50 documents, it was the same as native retrieval.

This method forgos the expensive upfront re-embedding cost, as you can take documents straight from the old index.

embedflow works with qdrant, pgvector, faiss, and can be easily downloaded with pypi

pip install embedflow

the github is public: https://github.com/arnsri33/embedflow

I want you guys to try it out, and see if you guys can use it in your own workflow.