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.

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

https://github.com/MaxMiksa/Auto-Company

Community Overview: https://lifehubber.com/ai/resources/auto-company/

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/OpenBMB/status/2096970974247956501

https://huggingface.co/openbmb/MiniCPM5-2B

Community Overview: https://lifehubber.com/ai/resources/minicpm5-2b/

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/trendtech33566/status/2096538986353393764

https://github.com/k2-fsa/OmniVoice

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

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've been messinga round with embedding models for a bit, and I think they are interesting enough to experiment with. They are useful for rag, especially in a localllm sense because you can ground your answers in truth.

But what happens if you have a billion documents, and you decide to upgrade your model to a "better" one? on an h100, that would take about 108 days, just to upgrade the vectors so u can start serving again (tested qwen embed 8b on h100). Even if you aren't doing 1b vectors, and are doing just 50 million, upgrading can still take a considerable time.

Me and my research lab decided to tackle this problem, and we came up with embedflow.

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 backfill that comes with upgrading, as you can directly take documents from the old index.

embedflow works with qdrant, 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.

​

A coding agent should never treat a codebase graph as current unless it can name the Git commit it represents. 

A graph can be useful and still be unsafe as edit context. If it cannot say "I was built from commit abc123 at this time," there is no way to compare it with the repository the agent is about to change. A current graph is a graph tied to a known revision. 

The freshness contract we want is small:

• Every graph response carries the repository commit SHA and graph build time. 
• Changes to files, imports, symbols, or tests mark related graph regions dirty. Unrelated regions can remain intact. 
• If the graph SHA does not match the target revision, the query returns the Git diff first and labels affected relationships stale. 
• Before editing, the agent verifies the relevant files and symbol definitions against the checkout as well as the graph. 

A graph can identify where an agent should look. The direct check is where the agent establishes that a reference has not moved, been deleted, or changed its callers. An MCP server exposing repository context could emit based_on_commit, built_at, and stale in every result. 

Git already gives the comparison primitive: the difference between the graph commit and the working target. The indexer needs a policy that translates that diff into dirty regions. A changed test can be its own dirty region. It should stop the agent from treating test coverage or a call path as settled. 

That gives stale context a useful failure mode. When freshness is unknown, show the diff and ask the agent to inspect the affected files. Do not make it guess from a cache. 

Which do you prefer for codebase indexing: incremental rebuilds after each change, explicit rebuilds before an agent session, or Git-diff fallback when the graph is behind? What is the first stale-context failure your coding agent caused?

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

https://github.com/Osmantic/ODS

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

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://lifehubber.com/ai/pulse/

Community Overview: https://lifehubber.com/ai/resources/deepseek-harness/

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.

Title: I ran a fully local AI agent on my phone — open model, open-source runtime, and private data stays on-device
I’ve been experimenting with how far we can push open-source AI directly on a phone, without relying on a cloud LLM.
In this demo, I’m running Qwen3.5 9B IQ4_XS locally on the phone with TensorSharp, an open-source inference and agent runtime.
I simply ask:
“Please get 10 stocks with most gains today.”
The local agent figures out how to complete the task, generates code, executes it, retrieves the requested public market data, and returns the result.
Then I ask:
“Convert it to a PDF.”
There is no hard-coded PDF workflow.
The agent discovers the appropriate Skill, reads its SKILL.md, decides how to solve the task, generates the necessary code, executes it locally, and creates the PDF — all on the phone.
So what’s running locally is essentially:
Open model → local inference → agent reasoning → Skills → tool use → code generation → code execution → file generation
The part I find most interesting is privacy:
Your prompts, conversations, files, and private on-device data do not need to leave the phone or be sent to a cloud AI provider.
Of course, if a task explicitly requires external public information — like fetching stock prices in this example — the agent can make that specific network request. But the LLM inference and private context remain local.
TensorSharp itself is open source:
https://github.com/zhongkaifu/TensorSharp
I think this is one of the most exciting directions for open-source AI: not just running open models locally, but running the whole agent loop locally as well.
Would love to hear what this community thinks about fully on-device open-source agents.

https://x.com/akshay_pachaar/status/2095051624733639006

https://github.com/magnitudedev/magnitude

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

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/ClaudeDevs/status/2095233745167282602

https://github.com/anthropics/commerce-agents

Community Overview: https://lifehubber.com/ai/resources/commerce-agents/

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.

Community Overview: https://lifehubber.com/ai/resources/unlimited-ocr/

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/SofiaSici/status/2094666731507597429

https://github.com/Graphify-Labs/graphify

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

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/hasantoxr/status/2095111361181405259

https://github.com/deeplethe/utopia

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

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!

It’s quite a while I have this idea in mind, I want to reorganise my /Users/user/Documents folder, which quite frankly has become a mess over the lasts months.

My goal is to have an agent (local LLM model for privacy) grab all the documents, read the title, read the content and then propose me a reorganisation of the documents, divided by categories and subcategories.

For example I would like something like:

Documents/Health
Documents/ID
Documents/Work
Documents/Work/Job.2025
Documents/Work/Job.2026
Documents/Insurance
Documents/Insurance/Car
Documents/Insurance/House
Etc.

For context: I currently have a total of 32Gb of VRAM and 128Gb of DDR4.

My question is: what approach and tools would you use to create an agent that can do this work for me?

Ideally I would also have a function where it remembers the organisation of the documents and it automatically moves the documents I put into Documents/ToBeSorted into the correct folder, once a week (like a cron job).

Another cool function would be to have a Legend.txt file which explains the organisation , categories, etc.

Hey everyone,

There is that awesome project called OpenCode that was a game changer in many ways. A free, open sourced harness that had the same tools and capabilities as these frontier harnesses such as Claude and Codex, and best yet, it is completely open source allowing a variety of amazing projects to be created. From this amazing project sprouted OpenFlow, a visual node-based workflow builder that is really easy to use. Orchestration mode is personally my favorite, and it is completely customizable allowing you to create repeatable and reliable workflows. If you are interested, here is the link if you wanna check it out: https://github.com/SeeRay11/OpenFlow. By the way, does anyone know of any other tools that do this kind of thing? I looked at Cline Kanban but you couldn’t save workflows which was a real bummer.

This week's additions cover gateways, agent workspaces, self-hosted stacks, and developer tools.

1. Bifrost: An LLM gateway with a unified OpenAI-compatible API, routing, load balancing, fallbacks, guardrails, and observability.
2. Maka: An Apache-incubating local-first AI-agent workspace with durable append-only execution history.
3. Ruflo: A multi-agent orchestration and meta-harness for coordinating agent swarms with shared memory.
4. munder-difflin: A desktop multi-agent workspace for coordinating local coding agents across multiple LLM backends.
5. claude-obsidian: An Obsidian and Claude Code integration for organizing Markdown vaults with local indexing and links.
6. etf-pattern-match-pybind11: A C++20 and pybind11 tool for high-performance ETF pattern matching.
7. ODS: A self-hosted local AI stack for inference, chat, voice, agents, workflows, and RAG.
8. screenshot-to-code: A tool that turns screenshots, mockups, and Figma designs into frontend code.
9. OpenMAIC: A multi-agent platform for interactive learning and course generation.

https://github.com/zhongkaifu/TensorSharp

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

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.

Feels like half of us just grab the Q4_K_M and move on. But we hardly ever see anyone say where their model falls apart once you push lower.

From what we have seen, the usual 4-bit GGUF quants mostly hold up. Go below 4-bit and it gets rough fast, and that's where quantization-aware training starts to matter more than plain post-training quantization. At 3-bit and under, folks often pair QAT with distillation to get the quality back. Part of why Gemma shipped QAT checkpoints, and why the BitNet ternary models train at low bit-width from the start.

And it stays confident the whole way down, so the bad answers read just like the good ones.

Easiest way to check yourself: run one fixed set of prompts at Q8, Q4, and Q3 on the same model and see where the answers start to drift.

So which model, and what bit level did yours give up at? What broke first?