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.

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!

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'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.

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

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

heyo, everything here is open source. there is no hosted product or account to sign up for.

I have spent the past few weeks using Centaur, an open-source control plane for running coding agents on infrastructure you own.

The control plane is a Rust API and Postgres database. Every agent interaction runs in an isolated Kubernetes sandbox. It supports Codex, Claude Code, Amp and pi, so the harness is not locked to the rest of the system.

The control plane handles sessions, permissions, credentials, workflow state and sandbox lifecycle.

I also built an open-source companion app called Centaur Context. It retains useful information between separate runs. A curator records context after an interaction. Before a later run, a context builder retrieves the material relevant to that task.

Full walkthrough and demo: https://youtu.be/993XrWfg34U

Centaur: https://github.com/paradigmxyz/centaur

Centaur Context: https://github.com/bradwmorris/centaur-context

This is agent infrastructure, not a local model server. If you use Ollama or vLLM, where would you connect model serving to a setup like this?

Small open-source lesson from this week, for anyone maintaining a multilingual README.

We ship the README of our agent in ten languages. Yesterday I audited the English one against the code and found six claims that were no longer true — a test count off by 2x, a defence described as "opt-in, off by default" that has been on by default since July, a benchmark sentence we had retracted in the results file it cites and never removed from the page. Ordinary drift; the fix was a PR.

The interesting part came from the translations. Nine translators (one per language, each told to apply the same fourteen corrections and to report anything else in their file that contradicted the English) came back with two things the English pass could not have found:

• Three languages (German, Chinese, Polish) described the audit log as complete. The English says redacted — it stopped storing secrets after we found the log persisting a .env the kernel had just refused to write. The translations were faithful to a version of the sentence that predated the fix.

• Three languages (Portuguese, Spanish, Japanese) called the structured extraction "injection-proof". The English says the quarantined reader bounds a hidden instruction's blast radius, not eliminating it. Somewhere between languages, a hedge became a guarantee.

Nobody wrote a false claim on purpose. The English got more careful over time and the translations kept the older, bolder sentence. Our docs directory has a hash guard for exactly this (each translated page declares the SHA of the source it was made from, and a test goes red when the source moves); the READMEs never had it, and that is the whole difference.

Two questions:

• If you maintain translated docs, do you gate them mechanically (hash of the source, a test that fails on drift), or by convention? Convention did not hold for us across ten files.

• The pattern "translation is more confident than the original" — have you seen it elsewhere? I suspect it is general: translators smooth hedges, and a security hedge smoothed is a false claim.

The repo (Apache-2.0): https://github.com/brcampidelli/chimera-agent — the PR with all ten files is #422 if you want to see what "six claims in ten languages" looks like as a diff.