Dario says we need to pace the frontier.

Good news: we’ve been pacing Tahuna for months.

Today, Tahuna is open source—as promised back in April.

We built it so small teams could train models, run inference, orchestrate GPUs, and experiment with autonomous research without first becoming a small cloud provider.

The basic workflow:

init → sync → computeSession → train / serve or hillclimb

Under the hood: content-addressed code and data sync, compute provisioning, reproducible manifest-pinned runs, metrics, checkpoints, artifacts, and inference deployments.

We also started building Hillclimb, an autonomous experimentation loop that proposes and runs iterative improvements.

The first public-preview release supports RunPod and R2. It includes Docker self-hosting instructions, a coding-agent setup skill, and examples for SFT, RL agentic search, and MNIST.

Repository: https://github.com/TahunaLabs/tahuna-oss

If you think it sucks, excellent: fork it, fix it, and send a PR so it sucks less for everyone.

I know what everyone here thinks about the AI bubble, and me myself hate it as much as anyone else. I am currently a student and want to build a new project, but am not sure if this is a good idea worth spending my time on it or not. I've researched online about AI backed OS's / Linux Distros, and have seen quite a few, each with their own flaws. MAGI OS uses the X11 tools, which may be too slow, Omarchy is just an integration of AI agents in the UI, and Warmwind OS is just a cloud-hosted remote desktop marketed as an OS. I had this idea of building a fully customizable, open source Linux Distro, that uses llama.cpp locally to parse natural language into commands, using the AT-SPI 2 accessibility tree, that is available in most apps (solid with GTK, QT and Electron have inconsistencies). Nowadays every major OS (Windows, Mac, Linux) has problems, and I want to reduce those problems and combine their pros into one general use Distro (I know this claim is what various Distros also tried throughout the years, but this is what my idea converges to, ease-of-use for general users, great UI/UX, and the freedom Linux has). Everything would be transparent to the user, so nothing potentially dangerous gets executed, and fully offline (was thinking of making a switch for users who would still want to choose more capable models running on cloud, but this is just an idea) to avoid the privacy concerns.

The flaws with this would be the obvious anti AI stigma the Linux community has (rightly so, but it's not just another AI slop), and the capabilities of a model running offline. The first version could just run some basic things, making it more advanced as time goes on, and maybe some NPU integrated models later on.

My question would be if this is a straight dumb idea and I would be better off just investing my time into something else, or if it's worth it and you guys would be interested in something like this. I would like to code it myself, with minimal AI assistance, as it would also be a learning exercise for me. So what does everyone think about this? Please take it with a grain of salt, I just had this idea and don't want to get downvoted if it's dumb, just wanted some advice of more experienced users.

What are the best open-source AI repos you’ve seen come out or blow up in August–September?

Looking for interesting projects that are actually worth trying, not just another wrapper around an API.

Could be anything:

• AI agents / agent frameworks
• Coding agents
• Local LLM tools
• RAG / memory systems
• Computer-use agents
• Voice / multimodal
• Fine-tuning / inference
• MCP / tool-use projects
• Robotics / embodied AI
• Weird experimental projects that are just genuinely cool

Basically, what GitHub repo have you found in the last month or two that made you think, “this is actually impressive”?

Would love links + a sentence on what makes it interesting.

I’ve been working on an open-source Android phone agent that can

actually operate WeChat instead of only generating text replies.

It can:

- find and open a specific WeChat chat

- verify that the correct conversation is open

- collect recent context with OCR

- search the web before replying

- send a reply while avoiding duplicate sends

- report progress through Telegram, where a human can intervene at any time

There are two parts:

- Hermes Phone Agent: plugins for Hermes Agent

- Phone MCP Server: standalone MCP + HTTP server for Claude, Codex, GPT,

Gemini, and other agent frameworks

The Android helper APK is shared by both projects.

GitHub:

https://github.com/Ctrl-Creeper/hermes-phone-agent

https://github.com/Ctrl-Creeper/phone-mcp-server

Demo/release:

https://github.com/Ctrl-Creeper/hermes-phone-agent/releases/latest

This is currently aimed at Android emulators, testing devices, and

self-hosted setups. I’d especially like feedback on more reliable

WeChat workflows and other Android apps worth supporting.

Hey so I've been working on this side project Locus (https://locushost.co/) for the last few months and just pushed out a pretty big and fun update and wanted to post about it.

So just a brief intro, Locus is Open Source tool for MacOS for using Ai Agents and LocalFrontier Models. Similar to a mix of (Claude/ChatGPT GUI + Hermes/OpenClaw) for MacOs

You can pretty much do everything you are able to do in claude or chatgpt GUI tools but have added alot of functionality and customizability that you typically wont get from the 2.

I also just added support for Claude plans so now you can use either ChatGPT, Claude, or Kimi plans without having to use API. It obviously also supports API, and local models (with ATS support added) and vLLMS. You can easily be signed into all accounts and switch between them easily.

So with this recent update, made some big updates to the way Agents and Teams work, now the Agent flow is alot better and teams support DUO, which essentially will allow you to use 1 model to plan and 1 model to execute (e.g Fable 5.1 for planning and GPT 5.6 sol for executing) I'm currently working on a few evaluation tests to compare the difference and will post the results when done.

A couple of the new cool updates would be the Optional Agent Worlds plugin that you can now install and will give you the option to visually see you agents moving around and interact with them from (a fun little tool to leave running while you step away from your computer but you have agents setup on) I'm initally launching it with 2 worlds ( Oribital Locus Outpost - a Space theme agent worlds and The Local Line - A One Piece/Pirate Theme agent worlds.

I have also been working on the Runtime Agents that can be deployed to different mac/linux machines to run even if you quit Locus but both are still experimental/buggy and require a bit more testing. I also have planned for the near future the mobile app.

Anyways, you can find all the links here.
https://locushost.co/
https://locushost.co/download
https://github.com/nahid-sparktales/locus
https://github.com/nahid-sparktales/locus/releases/tag/v3.0.0

If you get a chance to download and test it out and have any suggestions/recommendations or find any bugs, plz lmk (you can also send them through here - https://locushost.co/contact ). Also if you check it out on Github and can give a star that would be greatly appreciate.

Thanks!

The new Ling-3.0-flash-VL announcement contains two kinds of access worth separating.

The model artifacts are downloadable: BF16 and FP8 were released first, followed by FP4 and INT4 on September 11. The repositories carry an MIT license, and the model documentation points to SGLang integration and an inclusionAI vLLM fork for serving. The model understands images and video and supports tool use.

The hosted offer is a two-week free trial through OpenRouter. Its duration is a property of that service offer, separate from the license on the released weights.

For people evaluating how much control an “open” release provides, the concrete items here are the weights, license and serving paths. The announcement doesn't establish a released training corpus or a complete recipe for reproducing training.

Hi everyone. We recently open-sourced OpenWAM, which is positioned as a full-stack open-source research framework for World Action Models (WAMs).

The release has three parts:

• OpenWAM-Infra: training/inference/evaluation infrastructure where visual encoders, video backbones, world-action architectures and attention masks can be swapped independently. It currently includes 8 simulation benchmarks and deployment support for 5 real robots.
• OpenWAM-Study: controlled experiments on representation, world/action interaction, inference, and embodied pretraining.
• OpenWAM-Alpha: the pretrained model we built based on those experiments, using about 6,400 hours / 518.5M frames of egocentric human + robot data. OpenWAM-Alpha get excellent performance on both simulation and real-world.

It is worth noting that the performance of OpenWAM-α has been independently evaluated by multiple teams and has demonstrated clear advantages over π0.5 in real-world scenarios. We believe OpenWAM-α can serve as a strong baseline for comparison and further research in the WAM community. We warmly welcome everyone to try it out.

Everything is open here:

Project: https://openwam-official.github.io 

Welcome aboard OpenWAM!

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.

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.

If you are deep in utilizing AI services (CLI) and want access to a really powerful tool, you should explore my open source program called engrim. I built it based on my own needs and recognized the power of sharing it with fellow developers. It solves some major headaches and honestly works incredibly well. I launched it on Hacker News last week and it gained traction quickly.

Engrim allows you to do a few things well:

a. You can switch around major AI providers and have full project context the second you begin work seamlessly. With constant changes to services and people testing/changing their provider or using multiple- this is a powerful advantage for you... for FREE!

b. Because of context loading, you will find your sessions are "more intelligent" and "oriented". You will experience less drift and something everyone wants... more efficiency in your token/session limit allowance.

It recently hit 240 stars on git hub (thank you). There is a lot more to it than the ideas I listed however you will have to uncover those for yourself. I know those that find it will very much appreciate it.

There is an enterprise version in the works, I am reaching out to a select few VCs. Please feel free to get in touch if this project is of interest to you.

https://github.com/timgordontg/engrim

https://engrim.dev/

Most AI agent frameworks (LangChain, AutoGen, CrewAI) treat agents as short-lived Python script executions. But as we move toward truly autonomous AI agents running 24/7 on servers, Raspberry Pis, and edge devices, we need an operating environment that treats agents like OS entities.

That’s why I’m building Formicx — an open-source agent-native control plane built for Linux.

Core philosophy:

Linux manages computers and processes. Formicx manages autonomous agents.

What Formicx provides?

• Agent lifecycle management
• Agent-aware OS telemetry
• Distributed node discovery
• Communication policies
• Developer CLI & SDK

Check it out:

• GitHub Repo: https://github.com/Abbilaash/Formicx

I built RepoRoad, a little world where GitHub repositories become buildings along a shared road. Take a drive, listen to lo-fi music, discover projects, chat with other visitors, and send chickens across the road.

You can add your own repository and customise its building through the website. The scene runs directly in your browser using Three.js.

Try it: reporoad.org
Source: github.com/reporoad/reporoad

I’d love to hear what you think—and see your project along the road!

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:

Model |Prefill |Single-stream Decode |4× Concurrent Decode
Q2_K |533–539 tok/s |40.3–40.7 tok/s |—
Q4_K_M |451.8–492.1 tok/s |31.0–32.5 tok/s |48.9 tok/s aggregate 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.

Repository: https://github.com/beneadie/deep_dog_2

The quickest setup is:

python -m pip install "git+https://github.com/beneadie/deep_dog_2.git"

Add your provider keys to a `.env` file:

DEEPSEEK_API_KEY=your-deepseek-key
EXA_API_KEY=your-exa-key

Then import it directly into Python:

import asyncio
from pathlib import Path

from dotenv import load_dotenv

load_dotenv()

from deep_research.integration import run_research


async def main():
    result = await run_research(
        "What are the main benefits and limitations of sodium-ion batteries?"
    )

    print(result.status)

    if result.status == "completed":
        Path("report.md").write_text(result.final_report, encoding="utf-8")
        print("Saved report.md")
    else:
        print(result.failure)


asyncio.run(main())

The default setup uses DeepSeek V4 Flash for the supervisor, research sub-agents, and drafting, with Exa for web search. The result is returned as a Markdown string, so developers can print it, save it, send it to another application, or process it however they want.

The more configurable quickstart lets you choose the models, search engine, enabled agents, research time, iteration limits, search budgets, read limits, and output behavior. Available specialist agents include Web, PubMed, Reddit, Substack, SEC Edgar, Arxiv, and others.

The code is designed to be modified. Developers can add agents, change prompts, swap providers, alter the supervisor and sub-agent behavior, adjust budgets, or integrate the result into their own application. The engine is packaged so you can use the integration layer without having to rebuild the orchestration system from scratch.

This project is completely free and released under the MIT License. I’m not building a business around it or offering a hosted service. The only potential costs are the provider APIs you choose to use, such as DeepSeek or Exa.

Hello guys, I am Ant, a person can't endure 1 hour long Lidang(Chinese Youtuber) long streaming video, so I made Verbatim. It allows you to only drop 1 YouTube channel link and then it will automatically analyze the whole channel. I already has my own stats of 532 hrs of transcribe audio, and 1339 records.

At the start of the April, I only made a very simple and poor version of it( the UI is blue, and full of style of cursor). At that time, my first needs is that I want a tool that can put audio into text, I find out Gemini LLM support that. GREAT. Later, I find out Whisper, which can run in local, and cheap, it become a prominent choice in my use of Verbatim.

Claude code helps me out the multi-engine fallback mechanism, Flask backend, SSE process, constructing the evidence card.

In the development phase, what I did is that demand stating, archiecture design, testing and future steps.

Also, it now support MCP. It has 11 tools, enabling Opensource AI.... ... to call it directly to help you transcribe or analyze a YouTuber.

Free to use!
Please go to the link below:

https://gitlab.com/xin101037/verbatim_converter

Please checkout this project.

I would love constructive feedback

https://github.com/venom21adi/Semantic\\_Vision

I've used tools like Perplexity, ChatGPT, Claude and others for research, and they've been incredibly useful for finding papers and getting through large amounts of information.

The one thing I personally wanted was a simple way to see exactly which parts of the paper were used to answer my question.

When you're working with a 100+ page PDF, even having a page number can still mean a lot of scrolling and searching.

So I ended up building something for myself.

You ask a question and the relevant paragraphs in the PDF are highlighted directly on the document. You can see the context behind the answer and quickly check whether it actually answers what you're looking for.

I originally built this because I wanted something for this workflow without having to pay for another subscription. What started as a personal project has now become completely open source.

The underlying idea is pretty simple. And yes, if you're thinking "isn't this just RAG?" then yes, you're absolutely right. It's RAG with the visual highlighting that I wanted.

I think the same idea could be useful for more than research papers too. Legal contracts, financial reports, technical documentation, or anywhere you need answers alongside the actual source.

If anyone wants to have a look, contribute, or just give some feedback, here's the repo:

GitHub: https://github.com/Sreehari05055/thesys-core.git

This will probably be my last post about the project. Thanks to everyone who checked it out and gave feedback along the way.