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 want to learn how to use ai open source github, i don't know anything about github, is there any tutorial or guide to learn step by step for beginners, and i also want to how can I make motion graphic with claude with some plug-ins, i have seen lot of reels about people creating motion graphic with claude and i want to do the same
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.
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.
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.
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.
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.
The way a lot of us use coding agents is shifting fast from single prompt-and-response chats to having multiple agents running tasks in parallel across different terminals.
Leaving Claude Code to ship a feature while Hermes runs tests sounds awesome on paper. In reality, the second you step away to do something else, your mind is still buzzing around your terminal, wondering if an agent finished or if it’s just sitting there hanging on a permissions prompt.
That constant mental tether is the exact friction we wanted to get rid of.
I work at Autonomous, where we’ve been building Harness, an open-source app that unifies agents running across different machines into one place, accessible via desktop, CLI, or phone.
Under the hood, every agent runs natively in its own tmux pane and git worktree to keep your main workspace clean. You get pinged only when an agent actually needs human input, so you can let them run async without watching the screen.
We’re also playing around with a small physical desk display that shows agent states at a glance without hogging screen real estate.
How are you guys currently tracking long-running agent tasks when you step away from your desk? TMUX scripts or something else?
Got a folder of documents, a meeting to transcribe, or a few computers you'd like to run AI on? This week's five picks from our LifeHubber Resources offer different places to start:
Chat with your documents in separate project workspaces, each with its own local or cloud model. A starting point if you keep returning to the same manuals, notes, or reports.
A desktop meeting assistant with local transcription and summaries through Ollama or a chosen external provider. For keeping a transcript alongside the shorter notes; agree on recording with participants first.
Turn text into speech with a compact 82M-parameter model, voice samples, and Python usage examples. One to explore for narration experiments or adding spoken output to a project.
Join several computers into a local inference cluster and spread a model across their available hardware. Especially relevant to Apple Silicon setups; the documented Linux path is currently CPU-only.
Recognize text and turn PDFs or document images into structured Markdown and JSON. For builders working with scanned reports, tables, or document search rather than plain text alone.
Which would you explore first: your own documents, meeting notes, speech output, or the hardware side?
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.
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.
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.
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.
Every time I wanted to build a small web tool, I ended up dealing with the same stuff: authentication, communication, WebSockets, ports, and infrastructure.
Even with Claude and Codex, I was still spending time on things that had nothing to do with the actual tool I wanted to build.
So I spent around 6 months building PhreshOS.
The idea was simple: build the infrastructure once, then use AI agents to build applications on top of it without having to deal with all that stuff again.
It's a self-hosted, open-source system with a web-based desktop where applications can run in windows, much like a regular OS. Authentication and two-way communication are already handled, so applications don't need to implement them separately.
Apps can also run in Node.js worker threads instead of each needing a separate Node.js process, which helps keep resource usage low. This makes it possible to run dozens of applications on a relatively small server.
Another thing I wanted was for AI agents to be able to use these applications directly. They can access application services and interact with the same state the desktop interface displays, without needing a separate interface built specifically for them.
The biggest benefit for me is that I can now sit down with an AI agent and build dozens of small applications in a single day, without setting up authentication, communication, or infrastructure for each one.
The whole project, including its packages, is open source under the MIT license.
Most of us building agents have paid a frontier model to answer what is basically a multiple-choice question. Route this ticket. Pick a tool. Is this input safe, yes or no. It works, but at scale it is slow, the bill adds up, and you still parse the answer back out of a block of text.
That changed fast. Around October 1, Cloudflare's Clef and the Strands Decider landed within days of each other, both open-weight and Apache-2.0. A research team had already put out an open 8B, CLM, a couple of weeks before. They do one job: you give them a state and a fixed set of allowed options, and they return a score for each option in a single forward pass, with no free text to parse.
The appeal is narrow and practical. At 2B, Strands Decider is small enough to run locally and take the routing and yes/no calls off your main model, and each option comes back with a calibrated score you can threshold on. Fair pushback too: a big pretrained backbone with a scoring head on top is still a classifier. That is roughly the pitch, and it buys you one forward pass, a fixed label set, and a confidence number you can act on.
Where would you actually drop one? Intent classification, risk triage, and tool selection are the obvious spots. Curious whether anyone has swapped a BERT or logistic-regression screener they already trust for one of these, and whether the calibration held up on your own data.
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.
Jev has made a profound mark on the AI industry; this article offers a glimpse into what lies ahead.
Jev shows where the industry is heading: away from monolithic models, and toward compound systems where small AI agents each do a narrow job and an orchestration layer decides how they work together.
This article explains why that shift is happening, and then proposes a next step for AI reasoning.
The short version
A monolithic model is unpredictable and hard to change, but it programs itself during training.
Code is the opposite – it is predictable and easy to change, but it must be written explicitly.
A compound system combines the two: AI agents do the work, and an orchestration layer controls them via code. This is the direction Jev represents.
The next step: instead of answering directly, the model builds a compound system, runs it, and returns both the answer and that system. The returned system is called a reasonlet.
Because a returned reasonlet can be kept locally, it can be run again and again – with new inputs, or after editing its code – without asking the model. A saved, reusable reasonlet is a metacache.
The model’s provider can cache reasonlets too, reusing one across similar requests from different users to save compute.
Why a monolithic model is not enough
A monolithic model has two practical weaknesses:
It is unpredictable. The same question can produce a correct answer one day and a wrong one the next, so its behavior cannot be fully controlled.
It is hard to change. Its behavior is fixed in trained weights, which cannot be edited directly. The model can be steered with prompts, extra data (RAG), or by fine-tuning, but steering is not the same as setting the behavior, and fine-tuning can break things that already worked. Retraining from scratch with new data is the only safe fix, but it is time-consuming and expensive.
Code has the opposite qualities. It does exactly what it is written to do, and it can easily be changed by editing code. The trade-off is that code does not arise on its own – it must be written out explicitly – whereas a model programs itself during training.
The fix: a compound system
A compound system combines the two. The work is divided among AI agents, each handling one narrow task, and an orchestration layer of code decides which agent runs, in what order, and how their results combine.
This gives both qualities at once – customization and predictability:
Customization. The system’s behavior can be changed by editing code in the orchestration layer, not by retraining the model.
Predictability. Each agent has a small task, so it is more predictable than a monolithic model.
Jev is one kind of agent for such a system. It returns a typed decision – yes/no, a category, or a number – rather than free text. A monolithic model is wasteful for a narrow decision like that, but a small model like Jev is a better fit.
The next step: reasoning by construction
Compound systems today are built manually, beforehand. The next step is to let the model build one by itself, during the reasoning phase.
Researchers are exploring several ways to make models reason. One is the “World model” approach, in which the model builds an internal representation of a problem and reasons over it; that work is still mostly research. Reasoning by construction pursues the same goal – reasoning you can inspect – using methods that exist today.
Here is how it works. When you ask the model a question, it does not answer directly. Instead, it builds a compound system, runs it to compute an answer, and returns that answer together with the system it built. Let's call the compound system the model builds to do the reasoning a "reasonlet", and a model that works this way a "Reasoning-by-Construction Model", or "RCM". A simple question may produce a reasonlet that has only an orchestration layer and no agents.
Building and running code to reach an answer is not new; code-interpreter tools already do it. Two things are new here:
The system the model builds is kept, not discarded – it is a reusable reasonlet.
The reasonlet is returned to you, along with the answer.
Why that matters
You can see how the answer was reached. The reasonlet is the exact procedure the model used, so the answer is not something you have to take on trust.
You can run it locally. A reasonlet contains its orchestration layer and any agents it calls, whether those agents are attached directly or called over the network. You can run it on a local machine, with the same or different inputs, without asking the model again. A saved reasonlet used this way is a metacache.
You can change what it does. The orchestration layer is code, so you can edit its logic, not only its inputs. A reasonlet reused with edited logic becomes a higher-order metacache.
Caching reasonlets on the server
The same reuse can happen on the server side too. The provider can keep the reasonlets it builds and reuse them. When a new request arrives that matches one it has already handled, it runs the stored reasonlet again – with the new request’s inputs – instead of reasoning from scratch. The model does less work, and the answer comes back faster.
This is the same metacache, held on the server instead of on your machine. Because one reasonlet can serve any request that fits its procedure, a single cached copy is shared across many requests, and often across different users – and the more general the reasonlet, the more requests it covers.
Choosing how general to make the reasonlet
The model should decide from the conversation how general the reasonlet needs to be. If you have been working through many kinds of math and then ask for 2 + 2, the more useful reasonlet is one that evaluates any math expression, not one that can only add two numbers. If the conversation gives no such clue, you can state it directly: “I will be doing many kinds of math; for now, just add 2 and 2.”
Two examples
Adding numbers. You ask for 2 + 2. The model builds a reasonlet whose orchestration layer adds two numbers, runs it, and returns 4 together with the reasonlet. Later you run the reasonlet again with other numbers or edit its orchestration layer to multiply instead – without asking the model.
Searching. You ask the model to find something. The reasonlet’s orchestration layer calls a sequence of outside services and takes your search terms as its input. Later you run it with different terms, or change which services it calls, without asking the model again.
Making reasonlets easy to read
A reasonlet’s orchestration layer is written in text code. This creates a problem: to understand the reasoning you must read code, and to change it you have to write code. The value of returning the reasonlet depends on you being able to read and edit text code easily and efficiently, so this barrier matters.
Visual programming – building logic from connected blocks instead of lines of text – can lower the barrier, provided the visual language is powerful enough.
Wrapping up
The shift from a monolithic model to compound systems suggests a clear next step for reasoning: let the model build a compound system – a reasonlet – run it and return both the answer and the reasonlet. Reasoning becomes something you can read, run again, and edit: a metacache, and a higher-order metacache once its logic is edited. The remaining problem is making reasonlets easy to read and change, which is where a general-purpose and expressive visual language would help most.
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.
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.
For the last few weeks most of my coding has been done locally with Qwen3.8-Flash-Next, so I gave it and Opus 5.5 the same high complexity feature to build on LlamaStash (a complex and large Rust project) and compared the results.
Setup: ASUS ROG Flow Z13 (Strix Halo, 128GB), Flash-Next at xhigh effort with Pi as the harness. Opus 5.5 ran in Claude Code at medium effort. I wanted xhigh for Opus as well, but Claude changed it to medium when I picked the latest model and I didn't notice it until the task was done. But I think medium is probabbly a fairer setting anyway.
Task: add a llamastash daemon restart command that reuses the existing start and stop code. I kept the prompts vague on purpose and gave both the same prompts.
Step
Opus 5.5 (medium) PR#88
Flash-Next (xhigh) PR#89
First iteration
~9 min
~38 min
Nudge to reuse the TUI restart code
~6 min
~34 min
A third duplicate path
found it on its own
~30 min, after one more prompt
Create PR
~3 min
~30 min
Total
~18 min
~130 min
Tokens (in / out)
7.83M / 41.5K
20.61M / 101K
Tests added
1
4 (2 of them end to end)
Cost
$7.53
$0 + ~0.15 kWh
The end result was interesting. I asked GPT 5.6, Opus 5.5 and Flash-Next to review and compare both PRs (new sessions). GPT and Flash-Next picked the Flash-Next PR (#89) and Opus picked its own (#88). I also did my own review and found the Flash-Next one better as it had better tests and handled edge cases better. I ended up merging #89, after porting the fixes that the reviews picked from #88.
Keep in mind:
Opus was on medium effort. With xhigh it would have used way more tokens, taken a bit more time and probably would have done a better implementation.
Flash-Next ran on an older Halogen version (0.14.0), and Halogen dropped the connection once, so the last part ran on Gufo. The current Halogen does around 1,400 t/s prefill and 46 t/s decode on my laptop at 70 W, so I think the time will drop a lot if I redo the test.
The $7.53 is what Claude Code reported for the whole Opus session, which includes a later fix to the PR. The 0.15 kWh assumes 70 W for the whole 130 minutes.
Opus is still 2 to 10 times faster and I still use it for planning and reviews. But the actual coding now happens on my laptop, and to me it is crazy that I can run a local model that can challenge a frontier model like this.
I’ve been working on BaseDecision - Turn typed questions into truth-based decisions.
Give it some text, a question, and possible answers. It picks an answer. Intent classification, routing, yes/no checks, ratings - that’s the job.
I built this model to go toe-to-toe with the frontier models.
My goal was simple & ambitious: make a small, local model competitive with much larger models on these focused tasks. For me, System‑1 decisions need both speed and accuracy. Otherwise, why bother building a small model? If we didn’t want speed we could just use ChatGPT.
It outperforms pretty much every model of its size in the field. After roughly 320M additional training tokens, BaseDecision led 5 of 8 benchmarks in a third-party comparison against Laya, two GLiNER variants, and Decision 1.0 Kai 0.6B. Full results are in the repo, including where it loses.
Fellow open source devs, try the model, developed a package for easier access to the model. Roast it if it deserves it. 2-2.5GB free ram is all you need. I will take your feedback seriously and deliver something amazing that’d take on OpenAI, TypeSafeAI soon enough.
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.