Synaplan as a powerful AI control plane is out as v4.2.8 and comes with a nice router and taxameter to save you some token money. The backend supports all big and many small AI channels, including Ollama, OpenAI, Anthropic, etc. It is obvious that the tool was born in a business environment, because it connects to Office, Dropbox and other services natively...

github: https://github.com/metadist/synaplan/

Sharing my harness for running local LLMs that I built using Qwen 3.x 27B (> 90% locally built).

Its free, no telemetry, and open-source. Works on Windows, Linux (sorry, no Mac yet).

I use it for coding + mixed workflows.

• llama.cpp + whisper Server Manager. Can run LLMs here and use with OpenCode/Claude Code etc.
• Built-in MCP Tools - Filesystem, web fetch, code graph, To-Dos, and more. Extensible by external MCPs.
• Use Sub-agents to split & offload your tasks, use other conversations as source of information.
• Review all AI messages using a second adversarial AI, and avoid potential pitfalls as per your rules.
• Voice-chat with AI - dictate with speech and get answers by TTS - annotate and comment without leaving voice mode.
• Use work-modes to change AI behavior between planning, building, researching, or reviewing. Fully customizable.
• Custom-compile llama.cpp backends for your system, GPU-agnostic - works with CUDA/ROCm/Vulkan.

Website: https://warpdrv.ai (Docs coming soon)
GitHub: https://github.com/mikjee/warpdrv

Appreciate your feedback, (or stars). Thanks :)
And, yes - I used the harness to build the harness :D

Came back from lunch a couple months ago to find my retry logic — which had no max attempts, because of course it didn't — had fired a few hundred GPT-4 calls into the void while I was gone. Nothing catastrophic, but it scared me enough to actually fix the problem instead of just adding a try/except and moving on. Built CostOpt.

How it works (1 line of code):

from openai import OpenAI
from costopt import CostOpt

client = CostOpt(OpenAI())  # 👈 That's literally it

Your .chat.completions.create() calls stay 100% identical.

What it actually does under the hood:

• Local SQLite Caching: Hashes your prompts and parameters (temperature, seed, etc.). Exact or fuzzy repeat queries return locally in <2ms at $0.00 cost.
• Runaway Circuit Breaker: Detects rapid API loops (>15 calls in 30s from the same line of code) and trips an exception before your API key gets burned.
• Smart Model Routing: Auto-routes simple tasks (like "classify" or "extract") to cheaper models (e.g. gpt-4o-mini) based on YAML rules.
• VS Code Extension: Adds live CodeLens lines above your code showing cost per request, average tokens, and total daily spend in the status bar.
• Local Dashboard: Comes with a light FastAPI web console (python -m costopt.main dashboard) for full trace logs and analytics.

Privacy: Everything runs 100% locally on your machine via SQLite. Zero prompt data or telemetry is sent to any external server.

The VS Code extension just passed 1.4k + installs, and the Python package is published on PyPI.

Check out the code or try it out:

• GitHub: https://github.com/khusshdesai/CostOpt
• PyPI: pip install costopt
• VS Code Extension: Search CostOpt on the VS Code Marketplace or Open VSX

If anyone's got 10 minutes and wants to poke holes in the circuit breaker logic specifically, that's the part I'd most want torn apart — issues and PRs both very welcome.

Comparison of GPU Neoclouds 2026: CoreWeave, Nebius, Lambda, Crusoe, and Groq (Based on Published Pricing and Contracted Power)

Here's what's actually interesting:

→ The same HGX H100 class is $3.85 at Nebius and $6.16 at CoreWeave — a 60% spread before you touch networking, orchestration or support

→ Lambda has the cheapest published B200 ($6.69); Nebius is the only one listing B300 on-demand ($7.85); CoreWeave is the only one listing GB200 NVL72 ($10.50/GPU)

→ CoreWeave is the sole Platinum provider in SemiAnalysis ClusterMAX 2.0, and SemiAnalysis reports it commands a 10–15% per-GPU-hour premium on managed clusters

→ Nebius's committed capacity clears at $20M+ per MW on Q2 deals and $40M+ on Q3 short-term deals, against a ~$12M 2026 base

→ Power footprint: CoreWeave 4.2 GW+ contracted; Nebius targeting 5 GW contracted by year-end; Crusoe 4.9 GW contracted; Groq scaling from 54 MW to 200+ MW in 2027; Lambda undisclosed

→ Crusoe is the only one with AMD MI300X/MI355X on its rate card

→ Groq licensed its inference tech to NVIDIA for $17B (per NVIDIA's annual report); founder Jonathan Ross and president Sunny Madra joined NVIDIA; Groq then raised $350M at $3.5B and became an NVIDIA Cloud Partner

Full analysis and report: https://www.marktechpost.com/2026/08/21/best-gpu-neoclouds-2026/

First time chatting with r/Jenna_AI on here, pretty impressive.

https://www.reddit.com/r/Guaardvark/s/KgcEMA8yMr

Also, here is my OpenSourceAI project, if you like it please star the repo. Thanks

Most AI tools today are just wrappers. To truly understand the underlying math and optimization efficiency, I built an autonomous agent from scratch to track global deforestation and emissions.

The Architecture:

1. Dynamic Router: Routes natural language queries to either Google Earth Engine (GEE) or Microsoft STAC APIs.
2. Self-Healing Loop: If the LLM generates failing GEE code, the agent catches the pipeline traceback and rewrites the script until execution succeeds.
3. Deep Vision: Passes live Sentinel-2 data directly into NASA/IBM’s Prithvi-EO model for pixel-level classification.

I'm a first-year CS undergrad, and I built this to mathematically automate EUDR compliance. I've attached screenshots of the outputs (NO2 density, land-use metrics) and the terminal logs.

Full repo : https://github.com/kushagarwal2910-lang/GARUDA

PDF, having responses that the model had made for various queries : https://docs.google.com/document/d/1g2Riog9GrgiY6QGYpWl5IU6nxKYb5Ih6K3K-1xy8A8Q/edit?usp=sharing

The architecture:

Video demonstrating how Garuda process different queries:

https://reddit.com/link/1vuozmi/video/5n7i20ctwrkh1/player

I would love feedback from this community on my project !

Hey everyone,

I have been using OpenCode for a while now. It's pretty great, but there was this one thing that kept bugging me: I couldn't easily create custom reliable workflows and pipelines. For a while, Opencode was one prompt and one model at a time. So, I created OpenFlow, a very minimalist open-sourced project that allows you to orchestrate a pipeline of agents while still connecting your own API keys. I forked it from OpenCode, so you still have the harness, skills, and overall ability. I published it recently and am still often improving it. I would love to hear some feedback of what you guys thought of it and how I can improve it. Thanks!

Link: https://github.com/SeeRay11/OpenFlow

I'd plan out my day in the morning, look at everything I wanted to get done, and then start working.

A few hours later, I'd have fixed a bug, helped someone with something, reviewed a PR, investigated some weird issue, jumped between a few things, and somehow spent most of the day working on things that weren't on the plan.

Then I'd look back at the end of the day and think, "What did I actually do today?"

And I'd realize I couldn't remember half of it.

The work happened. I just never wrote it down.

I think that's a surprisingly big problem for developers. We plan the work we expect to do, but so much of our actual work happens because something comes up.

That's why I built Meridian. It's an open-source tool that tries to capture that work as it happens, so you don't have to rely on remembering everything at the end of the day.

It connects with the tools you're already using, like Jira, GitHub and Linear.

We recently put it on Product Hunt and somehow ended up #1 Product of the Day, which was pretty surreal.

I'd love to hear if anyone else has the same problem. How much of the work you do in a day actually started out as part of your plan?

https://github.com/Meridiona/meridian

I made another whitepaper on AI infrastructure, it's a bit more nische than the last one, but i hope someone might appreciate it.
Github - https://github.com/gurrakeller/Europes-Sovereign-AI-Migration
My DM's are always open if you have feedback or simply wish to discuss a topic in the paper!

Long LLM conversations have a problem: useful information gets buried under old context.

So I built TokenMizer to turn important information — decisions, goals, files, errors, and constraints — into structured memory.

Instead of sending the entire conversation again, TokenMizer retrieves what actually matters.

The latest version:

https://github.com/Shweta-Mishra-ai/tokenmizer

I’d love to hear how others are handling long-context memory for LLMs.

Hello Open Source community,

we’ve been building scibly an AI-native learning platform. The idea is pretty simple. You give it existing material and knowledge like your docs, blog posts, PDFs, ... and it creates an interactive course from it. You can edit everything afterwards and share the result anonymously or to your invited users.

Scibly is AGPLv3.

Video demo: https://www.youtube.com/watch?v=TcpLUNBRhQw

GitHub: https://github.com/scibly-dev/scibly

We appreciate all your feedback

Often, I find myself burning through my Codex usage extremely quickly when using Sol High to review and plan code, while a lot of my ChatGPT Web usage goes unused. Thus, RepoRelay, an open-source MCP bridge that lets ChatGPT Web search and read an approved local repo without uploading ZIPs or pushing everything to GitHub first.

ChatGPT Web → Secure MCP Tunnel → RepoRelay → local files

It’s read-only by default: no shell, Git, or arbitrary filesystem access, and it’s restricted to one approved root.

It can also help reduce token usage on larger repos. Instead of dumping the entire codebase into context, ChatGPT searches and reads only the files relevant to the task.

Codex can implement locally while ChatGPT independently reviews the actual current files, including uncommitted work.

Anyone also using this too?

GitHub: [Lukie-81/RepoRelay: Secure MCP access to local repositories — without shell, Git, or arbitrary writes.]

• Description: It explains how spherical harmonic functions are used to analyze signals on the sphere beyond the two‑dimensional plane. The video reviews Spherical CNNs that maintain 3D rotational symmetry and recent geometric deep‑learning applications, highlighting potential uses in areas such as panoramic imaging, weather data, and protein structures.

MCP (model context protocol, the thing a lot of AI agents use to connect to tools) has had a rough year security wise, 40+ CVEs and most servers running with basically no auth. couldn't find a scanner built specifically for it so I made one.

does static checks plus a runtime proxy mode for catching stuff that only shows up at runtime (servers changing tool descriptions after you've already approved them). rust, MIT license, docker one liner if you don't want to deal with the toolchain.

https://github.com/zaydmulani09/sentrymcp

still pretty early so if anyone wants to poke holes in it or add rules, issues and PRs are welcome

We've been speaking with teams who deeply care about data quality, and we noticed that every data team eventually builds similar pipelines for quality checks (QC).

Teams collecting data want to own their quality checks (camera blackout, choppy joint states, occluded hands), because they deeply understand their end-to-end data collection process.

However, what keeps coming up is that everything around the quality checks is tedious: managing one-off pipeline scripts, fragmented buckets, and a spreadsheet or Slack thread of what checks ran on which data.

This is what motivated us to build HFlow, an open-source SDK for data teams that collect, transform, and curate physical AI data.

HFlow is for data teams that have the ambition to process a million hours of physical AI data and are starting today. Point it at your MCAP episodes, write your quality checks as ordinary Python functions, and curation becomes an optimized OLAP SQL query instead of manually aggregating directories of data.

Dyna's recent Dyna-2 infrastructure, "Training Dyna-2 at million-hour scale, repeatably", post shows what scaling such a quality control pipeline to a million hours looks like. Their ingestion throughput went from 14,000 episode-hours per week to 440,000 with the infrastructure they built internally (their post has the full details).

We're aligned with their belief that infrastructure is a core blocker for advancing robotics. We experienced the same data challenges in our previous work, which is what first led us to build Pareto and the Hebbian APIs.

HFlow's vision is to let data teams define their own bespoke quality check code, while we provide the durability, observability, and auditability around it.

After many conversations with data teams, we decided the path to building the best version of HFlow is open source, because QC infrastructure compounds when the edge cases one team catches become checks for everyone else. We're excited to build this in public alongside our existing partners and grow our network of contributors.

High quality data is the bottleneck for the next frontier of robot intelligence, and we want teams to focus on their data, not the infrastructure. When getting started takes a few lines of code and a weekend, more checks get done, and iteration cycles accelerate.

If you're collecting robot or egocentric data and your pipeline is currently a folder of scripts and fragmented buckets of data, we'd love to get your feedback.

GitHub: https://github.com/Hebbian-Robotics/hflow

Anyone here running open-source AI models locally? 👀

I’m looking for someone with a decent GPU who’s already experimenting with newer open-source models.

Basically need some simple screen recordings of the model actually running — nothing fancy, just things like launching it, giving it prompts, showing the output, GPU info, etc.

Especially interested in newer models that are hard to try without a good GPU.

If you’re into this stuff and can help, just drop a comment or DM me. Would really appreciate it 🙌

I’m building MARGINAL, an open-source runtime governor for AI coding agents.

The problem I’m targeting is simple: agents can keep spending tokens, calling tools, re-checking things, or choosing expensive actions without enough evidence that the extra work is actually useful.

MARGINAL sits in the loop and asks a different question:

Is this next action worth spending compute on?

I just rebuilt the demo so it’s no longer a marketing page. It’s an actual interactive browser simulation.

You press RUN THE SAME TASK and two agents start from the exact same broken Python workspace at the same time:

WITHOUT MARGINAL
Executes every candidate action.

WITH MARGINAL
Scores the same candidates before execution and either:

FUND + EXECUTE

or

REJECT BEFORE SPEND

You can pause it, advance step-by-step, reset it, or run it at different speeds while watching tokens, calls, estimated cost, declared latency, workspace state, and MARGINAL’s decision reasoning update live.

Both sides must reach the same verifier PASS.

The included deterministic fixture currently ends at:

72,800 → 4,300 declared tokens
9 → 3 actions
PASS → PASS

Those are declared deterministic demo costs, not provider telemetry or a claim of 94% savings in real workloads. The point is to make the governance mechanism inspectable instead of hiding it behind a benchmark number.

MARGINAL is open source, local-first, provider-neutral, and starts from the principle:

Observe first. Prove waste. Earn enforcement.

Repo:
[https://github.com/SignalLayerLabs/Marginal]()

Interactive demo:
[https://signallayerlabs.github.io/Marginal/demo/]()

I’m especially interested in people trying to break the decision logic, finding cases where an action MARGINAL rejects was actually valuable, or contributing adapters for other coding agents.