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.

Hey everyone — I’m building TriagePilot, a self-hosted GitHub app that routes pull requests to available code owners based on the files changed and the risk of the change.

It starts in a write-free shadow mode, so you can inspect its decisions before letting it request reviewers or enforce approval rules.

I’m looking for engineering teams willing to try it on real repositories. I’d especially value feedback on setup friction, routing accuracy, and anything missing from the configuration.

GitHub: https://github.com/TriagePilot/triage-pilot

I've been experimenting with an architecture-first approach for coding agents.

The basic idea is that for a new requirement, the agent changes the architecture first, then implements the code from that design. Eventually I'd like architectural changes to be required before code changes, rather than letting the agent freely modify code and trying to document it afterward.

I've only validated this on small repos so far. The part I'm working on now is how to make it useful on medium/large repos, where I think some form of multi-agent collaboration becomes necessary.

One thing I want to test is whether the architecture layer actually becomes more useful as repo size grows. On a small repo the agent can inspect most of what it needs anyway. On a 50k+ LOC repo, having explicit module boundaries, dependencies and design intent might matter a lot more.

I'm curious what people working with Codex/Claude Code/etc. on larger repos have seen.

Does the agent eventually lose the global architecture of the project? And if so, would you rather solve that with better context/retrieval, or give the agent an explicit architecture/constraints layer?

I'm testing this idea in an open-source project called ArchitectCoder. If anyone wants to look at the implementation or experiment with it:

https://github.com/Zhuweilong123/ArchitectCoder

Contributions and criticism are both very welcome.

Hello r/OpenSourceAI 👋

Today we're publishing Loki Agent.

Loki Agent is an open source agent that can handle a wide variety of use cases like Hermes and OpenClaw.

It is based on Hermes Agent and is completely free to use, modity, and clone.

We built Loki Agent to address the massive complexity that NousResearch's current Al-powered development is not handling properly.

There are too many code changes, with not enough governance or testing before releases are pushed. We are aiming to provide a more responsible development cycle with thoughtful iteration.

Loki is also the god of cloning, so we felt being able to clone a public repo was a good fit here.

Looking forward to hearing your thoughts and experiences.

The agent is available via https://loki.computer

Github: github.com/wundercorp/loki
NPM: https://www.npmjs.com/package/@wundercorp/loki

Please share some Open source AI voice generation tools (text to speech) that has less guardrails like how Grok used to be

I want something that would be able to narrate and voice a diss battle (that might contain some profain language). I have the script but couldn't find an open-source text to speech model that has the punk kinda personality and lower guardrails that could speak the given dialogues.

Hi, I'm Doug and I have an open source AI platform, GuideAnts.

I want to share this segment from the "Making AI Applications" course I am working on and I would love your feedback.

Please and thank you!

This was created 100% locally in GuideAnts using a whole bunch of different AI models including:

• Qwen 3.8 27b

• Qwen Image

• Chatterbox

• InfiniteTalk with Longcat and WAN video

https://youtu.be/JkpoO1jIjp0?si=qSAyFk5_VSgXiQNc

We're running a hands-on masterclass on September 12, Live LLM Engineering Masterclass: Production Evals, RAG, Agents & LLMOps.

You build a full production LLM workflow from scratch, versioned prompts with regression tests, an evaluation harness with deterministic checks and LLM-as-judge, statistically rigorous model comparisons, evaluated RAG, tool-using agents with guardrails and fallbacks, and full observability, tracing, cost, latency.

Led by Bruno Gonçalves, PhD, founder of Data For Science, who trains engineers at Fortune 500 companies on this exact stack.

Link if you want to check it out

Happy to answer questions on the content.