r/AIDeveloperNews • • Mar 15 '26

I built a visual drag-and-drop ML trainer (no code required). Free & open source.

Thumbnail
gallery
355 Upvotes

For those are tired of writing the same ML boilerplate every single time or to beginners who don't have coding experience.

UPDATE: You can now install MLForge using pip.

To install MLForge, enter the following in your command prompt

pip install zaina-ml-forge

Then

ml-forge

MLForge is an app that lets you visually craft a machine learning pipeline.

You build your pipeline like a node graph across three tabs:

Data Prep - drag in a dataset (MNIST, CIFAR10, etc), chain transforms, end with a DataLoader. Add a second chain with a val DataLoader for proper validation splits.

Model - connect layers visually. Input -> Linear -> ReLU -> Output. A few things that make this less painful than it sounds:

  • Drop in a MNIST (or any dataset) node and the Input shape auto-fills to 1, 28, 28

  • Connect layers and in_channels / in_features propagate automatically

  • After a Flatten, the next Linear's in_features is calculated from the conv stack above it, so no more manually doing that math

  • Robust error checking system that tries its best to prevent shape errors.

Training - Drop in your model and data node, wire them to the Loss and Optimizer node, press RUN. Watch loss curves update live, saves best checkpoint automatically.

Inference - Open up the inference window where you can drop in your checkpoints and evaluate your model on test data.

Pytorch Export - After your done with your project, you have the option of exporting your project into pure PyTorch, just a standalone file that you can run and experiment with.

Free, open source. Project showcase is on README in Github repo.

GitHub: https://github.com/zaina-ml/ml_forge

Please, if you have any feedback feel free to comment it below. My goal is to make this software that can be used by beginners and pros.

This is v1.0 so there will be rough edges, if you find one, drop it in the comments and I'll fix it.


r/AIDeveloperNews • • Mar 24 '26

Want to Learn Machine Learning Without Writing Any Code?

Post image
120 Upvotes

I know that coding is a big roadblock for anyone who wants to learn ML; however, there are ways you can learn without writing a single line of code. One way is using MLForge, an interface that lets you craft ML pipelines using a node-based graph system.

If anyone wants to learn how to install MLForge and train their first image classification model, here's the tutorial: https://www.youtube.com/watch?v=aSBxPpcXqzc

Note: Before you start, be sure to have python installed on your system before you get started.

The project is open source, totally free.

Github: https://github.com/zaina-ml/ml_forge

If you have any feedback to say, feel free to do so.


r/AIDeveloperNews • • Mar 12 '26

CodeGraphContext - An MCP server that indexes local code into a graph database to provide context to AI assistants

100 Upvotes

Explore codebase like exploring a city with buildings and islands... using our website

CodeGraphContext- the go to solution for code indexing now got 2k stars🎉🎉...

It's an MCP server that understands a codebase as a graph, not chunks of text. Now has grown way beyond my expectations - both technically and in adoption.

Where it is now

  • v0.3.0 released

  • ~2k GitHub stars, ~400 forks

  • 75k+ downloads

  • 75+ contributors, ~200 members community

  • Used and praised by many devs building MCP tooling, agents, and IDE workflows

  • Expanded to 14 different Coding languages

What it actually does

CodeGraphContext indexes a repo into a repository-scoped symbol-level graph: files, functions, classes, calls, imports, inheritance and serves precise, relationship-aware context to AI tools via MCP.

That means:

  • Fast “who calls what”, “who inherits what”, etc queries

  • Minimal context (no token spam)

  • Real-time updates as code changes

  • Graph storage stays in MBs, not GBs

It’s infrastructure for code understanding, not just 'grep' search.

Ecosystem adoption

It’s now listed or used across: PulseMCP, MCPMarket, MCPHunt, Awesome MCP Servers, Glama, Skywork, Playbooks, Stacker News, and many more.

This isn’t a VS Code trick or a RAG wrapper- it’s meant to sit
between large repositories and humans/AI systems as shared infrastructure.

Happy to hear feedback, skepticism, comparisons, or ideas from folks building MCP servers or dev tooling.


r/AIDeveloperNews • • Mar 02 '26

Someone just rebuilt the entire AI assistant stack in Zig. It's called NullClaw. The binary is 678 KB. It uses ~1 MB of RAM. It boots in under 2 milliseconds. No runtime. No VM.

96 Upvotes

The smallest fully autonomous AI assistant infrastructure — a static Zig binary that fits on any $5 board, boots in milliseconds, and requires nothing but libc.

Features

  • Impossibly Small: 678 KB static binary — no runtime, no VM, no framework overhead.

  • Near-Zero Memory: ~1 MB peak RSS. Runs comfortably on the cheapest ARM SBCs and microcontrollers.

  • Instant Startup: <2 ms on Apple Silicon, <8 ms on a 0.8 GHz edge core.

  • True Portability: Single self-contained binary across ARM, x86, and RISC-V. Drop it anywhere, it just runs.

  • Feature-Complete: 22+ providers, 18 channels, 18+ tools, hybrid vector+FTS5 memory, multi-layer sandbox, tunnels, hardware peripherals, MCP, subagents, streaming, voice — the full stack.

Product featured: https://ainews.sh/functions/socialShare?id=69a5dc25c0effbbb00735ffc&type=product

Repo: https://github.com/nullclaw/nullclaw


r/AIDeveloperNews • • Mar 19 '26 Bravo

I built a free open-source tool that fine-tunes any LLM on your own documents and exports a GGUF no coding required

93 Upvotes

I've been building a tool called PersonalForge for the past few

weeks and finally got it to a state where I'm happy to share it.

What it does:

You upload your documents (PDF, Word, Excel, code files, notes)

and it automatically fine-tunes a local LLM on that data, then

exports a GGUF you can run offline with Ollama or LM Studio.

The whole thing costs $0.00 — training runs on free Google Colab T4.

How the pipeline works:

  1. Upload files → labeled by type (books, code, notes, data)

  2. Auto-generates training pairs with thinking chains

  3. 3 training modes to choose from:

    - Developer/Coder (code examples, best practices)

    - Deep Thinker (multi-angle analysis)

    - Honest/Factual (cites sources, admits gaps)

  4. Colab notebook fine-tunes using Unsloth + LoRA

  5. Exports GGUF with Q4_K_M quantization

  6. Run it offline forever

Supported base models:

Small (~20 min): DeepSeek-R1 1.5B, Qwen2.5 1.5B, Llama 3.2 1B

Medium (~40 min): Qwen2.5 3B, Phi-3 Mini, Llama 3.2 3B

Large (~80 min): Qwen2.5 7B, DeepSeek-R1 7B, Mistral 7B

Technical details for anyone interested:

- rsLoRA (rank-stabilized, more stable than standard LoRA)

- Gradient checkpointing via Unsloth (60% less VRAM)

- 8-bit AdamW optimizer

- Cosine LR decay with warmup

- Gradient clipping

- Early stopping with best checkpoint auto-load

- ChromaDB RAG pipeline for large datasets (50+ books)

- Multi-hop training pairs (connects ideas across documents)

- 60 refusal pairs per run (teaches the model to say

"I don't have that" instead of hallucinating)

- Flask backend, custom HTML/CSS/JS UI (no Streamlit)

The difference from RAG-only tools:

Most "chat with your docs" tools retrieve at runtime.

This actually fine-tunes the model so the knowledge

lives in the weights. You get both — fine-tuning for

core knowledge and RAG for large datasets.

What works well:

Uploaded 50 Python books, got a coding assistant that

actually knows the content and runs fully offline.

Loss dropped from ~2.8 to ~0.8 on that dataset.

What doesn't work (being honest):

- 536 training pairs from a small file = weak model

- You need 1000+ good pairs for decent results

- 7B models are tight on free Colab T4 (14GB VRAM needed)

- Not a replacement for ChatGPT on general knowledge

- Fine-tuning from scratch is not possible — this uses

existing base models (Qwen, Llama, etc.)

GitHub: github.com/yagyeshVyas/personalforge

Would appreciate feedback on:

- The training pair generation quality

- Whether the RAG integration approach makes sense

- Any bugs if you try it

Happy to answer questions about the pipeline.


r/AIDeveloperNews • • Mar 21 '26 Bravo

I built a free tool to scrape and chat with TikTok content

66 Upvotes

I built Tikkocampus: an open-source tool that turns TikTok creators into custom LLM chatbots. It trains on their videos transcriptions so you can chat directly with an AI version of them. Would love some reviews! Use cases: -Get all recipes from food creators -Get all advices mentionned by creators -Get all books recommendations


r/AIDeveloperNews • • Mar 03 '26

Someone just open sourced a fully autonomous AI hacker agent ('Shannon'): Point it at your web app, and it doesn't just scan for vulnerabilities. It actually exploits them. Real injections. Real auth bypasses. Real database exfiltrations.

57 Upvotes

Shannon is an AI pentester that delivers actual exploits, not just alerts.

Shannon's goal is to break your web app before someone else does. It autonomously hunts for attack vectors in your code, then uses its built-in browser to execute real exploits, such as injection attacks, and auth bypass, to prove the vulnerability is actually exploitable.

What Problem Does Shannon Solve?

Thanks to tools like Claude Code and Cursor, your team ships code non-stop. But your penetration test? That happens once a year. This creates a massive security gap. For the other 364 days, you could be unknowingly shipping vulnerabilities to production.

Shannon closes this gap by acting as your on-demand whitebox pentester. It doesn't just find potential issues. It executes real exploits, providing concrete proof of vulnerabilities. This lets you ship with confidence, knowing every build can be secured.....

Product featured: https://ainews.sh/functions/socialShare?id=69a72b4f226d352cf7abbf35&type=product

GitHub: https://github.com/KeygraphHQ/shannon


r/AIDeveloperNews • • Mar 30 '26

Cevahir AI - I built an end-to-end artificial intelligence production engine from scratch in 16 months

Thumbnail
github.com
49 Upvotes

This project was developed over a period of approximately 16 months.

Throughout the process, many modules were rewritten multiple times. The system evolved through continuous debugging, trial and error, and architectural learning.

As the project grew more complex, I organized it under multiple core modules. After defining the high level structure, I split responsibilities across modules following SOLID principles to keep the system maintainable and scalable.

The final system consists of 12 main modules and around 650 sub-files, covering the full pipeline from tokenization to training, model architecture, and cognitive management layers.

During development, I encountered and resolved multiple issues such as training collapse, EOS learning failures, and refactoring of hardcoded components.

The tokenizer was trained specifically for Turkish and achieved around 98% accuracy in internal tests. It is included in the repository as part of the open source contribution.

The model was trained on approximately 580K question-answer pairs and 50K raw text samples, split into 512-length sequences. After 20–25 epochs, early inference tests started producing coherent responses.

Example outputs:

Name

Cevahir

How are you

I am fine

Favorite animal

Dog, I think they are loyal

What is love

Romance

The goal of this project was not just to build a model, but to create a fully independent, end-to-end AI system that can run locally without external dependencies.

All components were built from scratch and shared as open source for developers who want to experiment, learn, or build their own systems.


r/AIDeveloperNews • • Feb 27 '26

Open source maintainers can get 6 months of Claude Max 20x free

47 Upvotes

Claude just launched a program offering 6 months of Max 20x for OSS maintainers and contributors.

Apply:
https://claude.com/contact-sales/claude-for-oss

Has anyone here tried it yet? Curious how strict the eligibility check is.


r/AIDeveloperNews • • Jul 01 '26

RAG is not memory — and developers are finally designing for that

43 Upvotes

A better pattern is emerging in AI engineering: teams are realizing that retrieval alone does not give agents continuity. Recent technical guidance on stateful AI systems argues that production agents need typed, durable, and scoped memory layers, not just larger prompts or a single vector store.

For developers, this is the real shift:

  • RAG helps models look things up; memory helps apps remember across sessions.

  • Stable preferences, policies, IDs, and decisions should live in structured memory, not float around in prompts.

  • Long-running agents work better with layered memory: recent context, summaries, semantic retrieval, episodic state, and a memory manager.

  • Durable memory needs governance, scope controls, and write rules so the system does not pollute itself with low-quality state.

The takeaway is that memory is starting to look less like a feature and more like architecture. As agents become persistent and user-specific, developers will need to design memory as a first-class system component.


r/AIDeveloperNews • • Apr 01 '26

We built an AI lie detector that learns YOUR voice — then catches you lying in real time

Post image
42 Upvotes

My team has been working on something wild using Glyphh Hyperdimensional Computing (HDC) — not a neural network, not an LLM. It encodes your voice into 2000-dimensional bipolar vectors and analyzes the geometry of how your voice changes when you lie.

How it works:

  1. You read a baseline phrase so Ada (our AI) learns your natural voice

  2. You tell Ada an obvious lie so she learns YOUR specific deception pattern — the micro-tremors, rhythm shifts, and vocal control changes unique to YOU

  3. Then you tell her anything — truth or lie — and she tells you which

She's analyzing 41 vocal features across 4 layers: identity, emotional state, cognitive load, and speech cadence. The key insight: your vocal tract produces involuntary markers (jitter, shimmer, harmonic-to-noise ratio) that you literally cannot fake, even if you speak calmly and deliberately.

The 5-signal detection algorithm looks for:

  • Micro-tremors — involuntary voice tremor you can't suppress

  • Overcorrection — when you try TOO hard to sound normal (suspiciously perfect vocal control)

  • Cross-layer consistency — truth shifts all voice layers together; lies create mismatches

  • Rhythm disruption — fabrication takes cognitive effort that disrupts natural pacing

  • Traditional divergence — raw stress deviation from your baseline

It's not perfect — a really calm, practiced liar can sometimes fool it. But the calibration step makes a huge difference. She's learning what YOUR lies sound like, not using some generic model.

Built with: HDC vectors in pgvector, openSMILE eGeMAPS feature extraction, Claude for Ada's verdict delivery, React + Three.js for the 3D visualization.

Try it: https://ada.glyphh.ai

Would love feedback — especially if you can consistently fool her. That helps us improve the model.


r/AIDeveloperNews • • Jul 06 '26

100+ Agentic AI and Agents Tutorials/Implementations and Notebooks [Colab Notebooks with Full Codes are included]

Post image
35 Upvotes

My dev team has been quietly building one of the most complete open-source AI agent and Agentic tutorial libraries on GitHub. It just crossed 2.7K stars.

Every notebook is a full, runnable implementation — not a snippet. Here's what's inside:

  1. Multi-agent orchestration across every major framework→ LangGraph, CrewAI, AutoGen, SmolAgents, Google ADK, CAMEL, OpenAI Agents, Mistral Agents → Planning, tool-calling, sub-agents, and critique-driven refinement

  2. Agent memory that actually persists→ Mem0, Memori, EverMem-style hierarchical memory with FAISS + SQLite → RL agents that learn which long-term memories to retrieve

  3. Reasoning and decision loops→ Tree-of-Thoughts with beam search and pruning → Streaming decision agents with online replanning and mid-execution adaptation

  4. The agent stack, end to end→ MCP servers, OAuth 2.1 for MCP, A2A communication protocols → Agentic RAG, knowledge graphs, cost-aware LLM routing

  5. Beyond agents→ 30+ topic folders: RAG, RL, Deep Learning, Computer Vision, NLP, Robotics, Voice AI, LLM Evaluation, Federated Learning, and more

Every tutorial pairs a Colab notebook with a full written walkthrough, so you can read the theory and run the code in the same sitting.

985 commits. 585 forks. All free.

If you're building agents in 2026, this is a resource worth bookmarking.

Full Repo: https://github.com/MARKTECHPOST-AI-MEDIA-INC/AI-Agents-Projects-Tutorials


r/AIDeveloperNews • • Sep 23 '26

NVIDIA Releases Nemotron 3 Diarization: A 100M-Parameter Open-Weight Model That Tracks 8 Speakers in Real Time

Post image
30 Upvotes

r/AIDeveloperNews • • Jun 20 '26

I reverse engineered Windows Copilot into a free OpenAI compatible API (GPT-4o, no API key, no billing)

29 Upvotes

So Microsoft gives you GPT-4o for free in Copilot. They just don't give you an API for it. So I made one.

It logs into your own Microsoft account once, saves the session, and exposes a local server at http://localhost:8000/v1 that speaks the OpenAI format. Point the official OpenAI SDK at localhost and it just works. Drop-in, zero code changes.

It's free because it uses your normal signed-in Copilot, no credits or paid plan(Which is free and unlimited). It's a drop-in OpenAI replacement that works with anything OpenAI compatible. It does streaming and multi-turn conversations.

It ends up being surprisingly useful as a smarter alternative to small local models for automation, side projects, and lightweight workloads where you don't want to burn real GPT-4o credits.

You can set it up on a spare Windows laptop or Windows server with a different Microsoft account (don't use original in case ban) and use it as a free AI endpoint for your own tools and agents.

Full disclaimer: it's an unofficial project, not affiliated with Microsoft, and it automates the consumer Copilot. It's intended for personal and educational use, so please don't abuse it.

It's my first time shipping something like this publicly, so I'm sure there are things I've missed or hidden bugs. Would genuinely love feedback on the approach, and whether the OpenAI compatibility layer holds up against your tools.

Roast it, I'll take notes. lol (If you need help to setup you can ask here or DM me)

Repo: https://github.com/sumitgautam0101/WIndows-Copilot-API


r/AIDeveloperNews • • Apr 10 '26

OmniRoute — open-source AI gateway that pools ALL your accounts, routes to 60+ providers, 13 combo strategies, 11 providers at $0 forever. One endpoint for Cursor, Claude Code, Codex, OpenClaw, and every tool. MCP Server (25 tools), A2A Protocol, Never pay for what you don't use, never stop coding.

27 Upvotes

OmniRoute is a free, open-source local AI gateway. You install it once, connect all your AI accounts (free and paid), and it creates a single OpenAI-compatible endpoint at localhost:20128/v1. Every AI tool you use — Cursor, Claude Code, Codex, OpenClaw, Cline, Kilo Code — connects there. OmniRoute decides which provider, which account, which model gets each request based on rules you define in "combos." When one account hits its limit, it instantly falls to the next. When a provider goes down, circuit breakers kick in <1s. You never stop. You never overpay.

11 providers at $0. 60+ total. 13 routing strategies. 25 MCP tools. Desktop app. And it's GPL-3.0.

GitHub: https://github.com/diegosouzapw/OmniRoute

The problem: every developer using AI tools hits the same walls

  1. Quota walls. You pay $20/mo for Claude Pro but the 5-hour window runs out mid-refactor. Codex Plus resets weekly. Gemini CLI has a 180K monthly cap. You're always bumping into some ceiling.

  2. Provider silos. Claude Code only talks to Anthropic. Codex only talks to OpenAI. Cursor needs manual reconfiguration when you want a different backend. Each tool lives in its own world with no way to cross-pollinate.

  3. Wasted money. You pay for subscriptions you don't fully use every month. And when the quota DOES run out, there's no automatic fallback — you manually switch providers, reconfigure environment variables, lose your session context. Time and money, wasted.

  4. Multiple accounts, zero coordination. Maybe you have a personal Kiro account and a work one. Or your team of 3 each has their own Claude Pro. Those accounts sit isolated. Each person's unused quota is wasted while someone else is blocked.

  5. Region blocks. Some providers block certain countries. You get unsupported_country_region_territory errors during OAuth. Dead end.

  6. Format chaos. OpenAI uses one API format. Anthropic uses another. Gemini yet another. Codex uses the Responses API. If you want to swap between them, you need to deal with incompatible payloads.

OmniRoute solves all of this. One tool. One endpoint. Every provider. Every account. Automatic.

The $0/month stack — 11 providers, zero cost, never stops

This is OmniRoute's flagship setup. You connect these FREE providers, create one combo, and code forever without spending a cent.

#ProviderPrefixModelsCostAuthMulti-Account
1Kirokr/claude-sonnet-4.5, claude-haiku-4.5, claude-opus-4.6$0 UNLIMITEDAWS Builder ID OAuth✅ up to 10
2Qoder AIif/kimi-k2-thinking, qwen3-coder-plus, deepseek-r1, minimax-m2.1, kimi-k2$0 UNLIMITEDGoogle OAuth / PAT✅ up to 10
3LongCatlc/LongCat-Flash-Lite$0 (50M tokens/day 🔥)API Key—
4Pollinationspol/GPT-5, Claude, DeepSeek, Llama 4, Gemini, Mistral$0 (no key needed!)None—
5Qwenqw/qwen3-coder-plus, qwen3-coder-flash, qwen3-coder-next, vision-model$0 UNLIMITEDDevice Code✅ up to 10
6Gemini CLIgc/gemini-3-flash, gemini-2.5-pro$0 (180K/month)Google OAuth✅ up to 10
7Cloudflare AIcf/Llama 70B, Gemma 3, Whisper, 50+ models$0 (10K Neurons/day)API Token—
8Scalewayscw/Qwen3 235B(!), Llama 70B, Mistral, DeepSeek$0 (1M tokens)API Key—
9Groqgroq/Llama, Gemma, Whisper$0 (14.4K req/day)API Key—
10NVIDIA NIMnvidia/70+ open models$0 (40 RPM forever)API Key—
11Cerebrascerebras/Llama, Qwen, DeepSeek$0 (1M tokens/day)API Key—

Count that. Claude Sonnet/Haiku/Opus for free via Kiro. DeepSeek R1 for free via Qoder. GPT-5 for free via Pollinations. 50M tokens/day via LongCat. Qwen3 235B via Scaleway. 70+ NVIDIA models forever. And all of this is connected into ONE combo that automatically falls through the chain when any single provider is throttled or busy.

Pollinations is insane — no signup, no API key, literally zero friction. You add it as a provider in OmniRoute with an empty key field and it works.

The Combo System — OmniRoute's core innovation

Combos are OmniRoute's killer feature. A combo is a named chain of models from different providers with a routing strategy. When you send a request to OmniRoute using a combo name as the "model" field, OmniRoute walks the chain using the strategy you chose.

How combos work

Combo: "free-forever"
  Strategy: priority
  Nodes:
    1. kr/claude-sonnet-4.5     → Kiro (free Claude, unlimited)
    2. if/kimi-k2-thinking      → Qoder (free, unlimited)
    3. lc/LongCat-Flash-Lite    → LongCat (free, 50M/day)
    4. qw/qwen3-coder-plus      → Qwen (free, unlimited)
    5. groq/llama-3.3-70b       → Groq (free, 14.4K/day)

How it works:
  Request arrives → OmniRoute tries Node 1 (Kiro)
  → If Kiro is throttled/slow → instantly falls to Node 2 (Qoder)
  → If Qoder is somehow saturated → falls to Node 3 (LongCat)
  → And so on, until one succeeds

Your tool sees: a successful response. It has no idea 3 providers were tried.

13 Routing Strategies

StrategyWhat It DoesBest For
PriorityUses nodes in order, falls to next only on failureMaximizing primary provider usage
Round RobinCycles through nodes with configurable sticky limit (default 3)Even distribution
Fill FirstExhausts one account before moving to nextMaking sure you drain free tiers
Least UsedRoutes to the account with oldest lastUsedAtBalanced distribution over time
Cost OptimizedRoutes to cheapest available providerMinimizing spend
P2CPicks 2 random nodes, routes to the healthier oneSmart load balance with health awareness
RandomFisher-Yates shuffle, random selection each requestUnpredictability / anti-fingerprinting
WeightedAssigns percentage weight to each nodeFine-grained traffic shaping (70% Claude / 30% Gemini)
Auto6-factor scoring (quota, health, cost, latency, task-fit, stability)Hands-off intelligent routing
LKGPLast Known Good Provider — sticks to whatever worked lastSession stickiness / consistency
Context OptimizedRoutes to maximize context window sizeLong-context workflows
Context RelayPriority routing + session handoff summaries when accounts rotatePreserving context across provider switches
Strict RandomTrue random without sticky affinityStateless load distribution

Auto-Combo: The AI that routes your AI

  • Quota (20%): remaining capacity

  • Health (25%): circuit breaker state

  • Cost Inverse (20%): cheaper = higher score

  • Latency Inverse (15%): faster = higher score (using real p95 latency data)

  • Task Fit (10%): model × task type fitness

  • Stability (10%): low variance in latency/errors

4 mode packs: Ship Fast, Cost Saver, Quality First, Offline Friendly. Self-heals: providers scoring below 0.2 are auto-excluded for 5 min (progressive backoff up to 30 min).

Context Relay: Session continuity across account rotations

When a combo rotates accounts mid-session, OmniRoute generates a structured handoff summary in the background BEFORE the switch. When the next account takes over, the summary is injected as a system message. You continue exactly where you left off.

The 4-Tier Smart Fallback

TIER 1: SUBSCRIPTION

Claude Pro, Codex Plus, GitHub Copilot → Use your paid quota first

↓ quota exhausted

TIER 2: API KEY

DeepSeek ($0.27/1M), xAI Grok-4 ($0.20/1M) → Cheap pay-per-use

↓ budget limit hit

TIER 3: CHEAP

GLM-5 ($0.50/1M), MiniMax M2.5 ($0.30/1M) → Ultra-cheap backup

↓ budget limit hit

TIER 4: FREE — $0 FOREVER

Kiro, Qoder, LongCat, Pollinations, Qwen, Cloudflare, Scaleway, Groq, NVIDIA, Cerebras → Never stops.

Every tool connects through one endpoint

# Claude Code
ANTHROPIC_BASE_URL=http://localhost:20128 claude

# Codex CLI
OPENAI_BASE_URL=http://localhost:20128/v1 codex

# Cursor IDE
Settings → Models → OpenAI-compatible
Base URL: http://localhost:20128/v1
API Key: [your OmniRoute key]

# Cline / Continue / Kilo Code / OpenClaw / OpenCode
Same pattern — Base URL: http://localhost:20128/v1

14 CLI agents total supported: Claude Code, OpenAI Codex, Antigravity, Cursor IDE, Cline, GitHub Copilot, Continue, Kilo Code, OpenCode, Kiro AI, Factory Droid, OpenClaw, NanoBot, PicoClaw.

MCP Server — 25 tools, 3 transports, 10 scopes

omniroute --mcp
  • omniroute_get_health — gateway health, circuit breakers, uptime

  • omniroute_switch_combo — switch active combo mid-session

  • omniroute_check_quota — remaining quota per provider

  • omniroute_cost_report — spending breakdown in real time

  • omniroute_simulate_route — dry-run routing simulation with fallback tree

  • omniroute_best_combo_for_task — task-fitness recommendation with alternatives

  • omniroute_set_budget_guard — session budget with degrade/block/alert actions

  • omniroute_explain_route — explain a past routing decision

  • + 17 more tools. Memory tools (3). Skill tools (4).

3 Transports: stdio, SSE, Streamable HTTP. 10 Scopes. Full audit trail for every call.

Installation — 30 seconds

npm install -g omniroute
omniroute

Also: Docker (AMD64 + ARM64), Electron Desktop App (Windows/macOS/Linux), Source install.

Real-world playbooks

Playbook A: $0/month — Code forever for free

Combo: "free-forever"
  Strategy: priority
  1. kr/claude-sonnet-4.5     → Kiro (unlimited Claude)
  2. if/kimi-k2-thinking      → Qoder (unlimited)
  3. lc/LongCat-Flash-Lite    → LongCat (50M/day)
  4. pol/openai               → Pollinations (free GPT-5!)
  5. qw/qwen3-coder-plus      → Qwen (unlimited)

Monthly cost: $0

Playbook B: Maximize paid subscription

1. cc/claude-opus-4-6       → Claude Pro (use every token)
2. kr/claude-sonnet-4.5     → Kiro (free Claude when Pro runs out)
3. if/kimi-k2-thinking      → Qoder (unlimited free overflow)

Monthly cost: $20. Zero interruptions.

Playbook D: 7-layer always-on

1. cc/claude-opus-4-6   → Best quality
2. cx/gpt-5.2-codex     → Second best
3. xai/grok-4-fast      → Ultra-fast ($0.20/1M)
4. glm/glm-5            → Cheap ($0.50/1M)
5. minimax/M2.5         → Ultra-cheap ($0.30/1M)
6. kr/claude-sonnet-4.5 → Free Claude
7. if/kimi-k2-thinking  → Free unlimited

GitHub: https://github.com/diegosouzapw/OmniRoute
Free and open-source (GPL-3.0). 2500+ tests. 900+ commits.

Star ⭐ if this solves a problem for you. PRs welcome — adding a new provider takes ~50 lines of TypeScript.


r/AIDeveloperNews • • Sep 18 '26

Jev is changing the game again!

23 Upvotes

Not sure if you guys have seen this but this is the most exciting thing I’ve seen in a while. Lots of stuff out there from people who got invited early but this is a massive game changer.

Not everything requires a language model. Jev allows you to create the rules for decision making. And only when you need a language model do you call one.

Insanely fast. Insanely cheap. Probably top 3 of things exciting me, and likely number 1.

https://typesafe.ai/blog/introducing-system-one-models-and-jev


r/AIDeveloperNews • • Jul 23 '26

Andrew Ng Just Released OpenWorker: An Open-Source, Local-First Desktop AI Coworker That Returns Finished Deliverables Instead of Chat

23 Upvotes

Andrew Ng Just Released OpenWorker: An Open-Source, Local-First Desktop AI Coworker That Returns Finished Deliverables Instead of Chat

Here are some key takeaways:

  1. The approval layer is typed, not cosmetic

Most desktop agents bolt approvals onto the UI. OpenWorker classifies every tool call into one of four risk classes before it runs:

→ read — no side effects, always allowed

→ write_local — mutates the workspace, path-scoped

→ exec — runs commands

→ external — side effects off the machine

Five permission modes then decide what happens: discuss, plan, interactive (default), auto, custom.

2. Unattended ≠ more autonomous

Unattended mode doesn't raise the autonomy ceiling. It only reroutes approval prompts to an Inbox and suspends the run until a human answers. Autonomy and attention are separate axes — most agent frameworks conflate them.

3. No inference service, by design

You bring a key or run local:

→ 30 curated models, 13 providers

→ Native OpenAI / Anthropic / Google, open-weight via Together and Fireworks

→ Fully local via Ollama, no key

→ Matrix limited to tool-calling models — anything else stalls the agent loop

The stack

→ Tauri 2 + React shell over a local Python FastAPI server (127.0.0.1:8765)

→ 35 connectors live, plus any MCP server

→ Built on aisuite, ~32.4k lines of Python, 78 test modules

Full analysis: https://www.marktechpost.com/2026/07/23/andrew-ng-just-released-openworker-an-open-source-local-first-desktop-ai-coworker-that-returns-finished-deliverables-instead-of-chat/

Repo: https://github.com/andrewyng/openworker

Project: https://openworker.com/


r/AIDeveloperNews • • Jun 27 '26

I reverse engineered DeepSeek Chat into a free OpenAI compatible API (V4 & R1 models, no API key, no billing)

21 Upvotes

Some of you may remember my previous project where I turned Windows Copilot into an OpenAI-compatible API. That project ended up helping quite a few people with hobby projects and personal automations.

This time I did something similar for DeepSeek Chat which is wayyyyy more capable than previous one(1M context, reasoning, search capable).

DeepSeek already has an official OpenAI-compatible API, but it's paid. The web chat, on the other hand, is free. So I built a wrapper that lets you use your normal DeepSeek account through an OpenAI-compatible API.

It logs into your DeepSeek account once, saves the session, and exposes a local server at http://localhost:8000/v1 that speaks the OpenAI API format. Point the official OpenAI SDK at localhost and it just works. Drop-in, zero code changes.

It supports streaming, multi-turn conversations, and works with most OpenAI-compatible tools, agents, and SDKs.

I originally built it for lightweight automations and hobby projects where paying for API tokens didn't make much sense. It's been surprisingly useful as a free endpoint for small side projects and experimentation.

Full disclaimer: this is an unofficial project, not affiliated with DeepSeek. It automates the consumer web chat and is intended for personal and educational use. Please don't abuse it.

I'd genuinely appreciate feedback, bug reports, and compatibility testing with your favorite tools.

Roast it, I'll take notes 😄

Deepseek Repo: https://github.com/sums001/Deepseek-API
For MSFT Copilot : https://github.com/sums001/Windows-Copilot-API


r/AIDeveloperNews • • Apr 06 '26

CodeGraphContext - An MCP server that converts your codebase into a graph database

20 Upvotes

CodeGraphContext- the go to solution for graph-code indexing 🎉🎉...

It's an MCP server that understands a codebase as a graph, not chunks of text. Now has grown way beyond my expectations - both technically and in adoption.

Where it is now

  • v0.4.0 released

  • ~3k GitHub stars, 500+ forks

  • 50k+ downloads

  • 75+ contributors, ~250 members community

  • Used and praised by many devs building MCP tooling, agents, and IDE workflows

  • Expanded to 15 different Coding languages

What it actually does

CodeGraphContext indexes a repo into a repository-scoped symbol-level graph: files, functions, classes, calls, imports, inheritance and serves precise, relationship-aware context to AI tools via MCP.

That means:

  • Fast “who calls what”, “who inherits what”, etc queries

  • Minimal context (no token spam)

  • Real-time updates as code changes

  • Graph storage stays in MBs, not GBs

It’s infrastructure for code understanding, not just 'grep' search.

Ecosystem adoption

It’s now listed or used across: PulseMCP, MCPMarket, MCPHunt, Awesome MCP Servers, Glama, Skywork, Playbooks, Stacker News, and many more.

This isn’t a VS Code trick or a RAG wrapper- it’s meant to sit
between large repositories and humans/AI systems as shared infrastructure.

Happy to hear feedback, skepticism, comparisons, or ideas from folks building MCP servers or dev tooling.

Original post (for context):
https://www.reddit.com/r/mcp/comments/1o22gc5/i_built_codegraphcontext_an_mcp_server_that/


r/AIDeveloperNews • • Mar 05 '26

We open-sourced SocratiCode: a laser-focused, zero-setup MCP for local and private codebase indexing, hybrid search, code-graph, and infra/doc context, battleground tested for enterprise.

20 Upvotes

I've battled for a long time trying to find a proper codebase indexing solution, and I always found the existing solutions either bloated and overly complex to implement/use, or missing essential things for real-world usage.

And very often not working, not maintained, and seemingly not tested with real dev teams, in particular when dealing with large codebases (over 100k lines of code up to millions of lines of code), and with projects needing not just code but also infrastructure or documentation context in the same place.

In short, SocratiCode tries to do one thing well: deep codebase intelligence for AI, zero setup, no bloat.

The best solutions I found out there are part of paid products/subscriptions, so we decided to release as open source the MCP we created and use, called SocratiCode, in the hope it can be useful to others.

Make sure you have Docker, add SocratiCode to any MCP host (VS Code, Cursor, Claude Desktop, Windsurf, Cline, Claude Code, Codex, etc.) with a one-liner config, and it handles everything else automatically: pulls Docker images, starts Qdrant and Ollama (if you don't have one already installed), downloads the embedding model. That's it! Of course, there's a bunch of configuration available if you want to.

Under the hood: AST-aware code chunking, hybrid semantic + BM25 search (RRF-fused), polyglot dependency graphs with circular dependency detection, and searchable context artifacts (database schemas, API specs, infra configs, architecture docs). Incremental indexing with automatic checkpointing — crashes and restarts don't lose work. File watcher keeps things updated automatically.

Let me know what you think, I hope you'll find it useful.

https://github.com/giancarloerra/socraticode


r/AIDeveloperNews • • Jul 18 '26

Google Cloud’s Always-On Memory Agent Replaces RAG and Embeddings With Continuous LLM Consolidation on Gemini 3.1 Flash-Lite

19 Upvotes

Google Cloud Open-Sources an Always-On Memory Agent: A 24/7 Background Agent on Google ADK + Gemini 3.1 Flash-Lite That Persists Memory Without a Vector DB.

No vector DB. No embeddings. No RAG.

Here's how it works. 👇

  1. Memory as a running process, not a lookup The agent runs 24/7 as a lightweight background process. An orchestrator routes every request to one of three sub-agents. An LLM reads, thinks, and writes structured memory — no retrieval index anywhere.

  2. Ingest, multimodal extraction The IngestAgent uses Gemini to turn any file into a structured record.

→ summary, entities, topics, importance (0.0–1.0)

→ 27 file types: text, images, audio, video, PDFs

→ drop a file in ./inbox, auto-ingested in seconds

3. Consolidate, runs every 30 min like sleep cycles The ConsolidateAgent reviews unconsolidated memories while idle.

→ finds connections across memories

→ writes a summary + one cross-cutting insight + connections

→ no prompt needed

4. Query, grounded and cited The QueryAgent reads all memories and consolidation insights, then synthesizes.

→ reads up to 50 recent memories

→ cites memory IDs: [Memory 1], [Memory 2]

5. The stack Google ADK orchestrator + 3 sub-agents (Ingest, Consolidate, Query), SQLite for storage, aiohttp HTTP API on :8888.

→ MIT license, no vector infra

The key takeaway: persistent agent memory as an active background process — multimodal ingest, timed consolidation, cited queries — on one LLM and SQLite, no vector DB and no embeddings.

Full analysis: https://www.marktechpost.com/2026/07/18/google-clouds-always-on-memory-agent-replaces-rag-and-embeddings-with-continuous-llm-consolidation-on-gemini-3-1-flash-lite/

Repo: https://github.com/GoogleCloudPlatform/generative-ai/tree/main/gemini/agents/always-on-memory-agent


r/AIDeveloperNews • • Oct 14 '26

Purpose-built to stress-test computer vision models, depth cameras, and spatial AI against severe specular glare and geometric reflections.

Thumbnail
gallery
18 Upvotes

I took photos of a human wearing a multi angled mirrored suit for training autonomous vision models to handle specular glare and complex reflections?'Mirror Suit' Robotics Data archive is now live on Mozilla Data Collective


r/AIDeveloperNews • • Jul 16 '26

SpaceXAI Open-Sources Grok Build: The Rust Agent Harness, TUI, and Tool Layer Behind Its Coding CLI, Under Apache 2.0.

Post image
17 Upvotes

SpaceXAI Open-Sources Grok Build: The Rust Agent Harness, TUI, and Tool Layer Behind Its Coding CLI, Under Apache 2.0.

Here are some important details:

  1. It's the harness, not the model
    A harness is the scaffolding around a model: assemble context, call the model, parse the reply, dispatch tool calls. That loop is what shipped. Grok 4.5 stays closed.
    → 99.6% Rust, Apache 2.0 on first-party code
    → Published July 15, 2026 at xai-org/grok-build

  2. The crate map is the reading order
    xai-grok-shell holds the agent runtime plus the leader/stdio/headless entry points. xai-grok-tools holds the terminal, file edit, and search implementations. xai-grok-workspace owns the host filesystem, VCS, execution, and checkpoints. xai-grok-pager is the TUI: scrollback, prompt, modals, rendering.
    → Start at xai-grok-shell for the loop, then xai-grok-tools for what the model can actually do
    → The binary artifact is xai-grok-pager; official installs ship it as grok

  3. Local-first is now a real path
    Declare any model in ~/.grok/config.toml with model, base_url, name, and env_key, then set [models] default. Run grok inspect and it prints what the harness discovered in that directory: config sources, instructions, skills, plugins, hooks, MCP servers.
    → Point base_url at local inference and http://api.x.ai leaves the loop entirely
    → Three surfaces: interactive TUI, headless -p for CI, ACP for editor embedding

  4. The tool layer contains ported code
    THIRD-PARTY-NOTICES documents in-tree source ports from openai/codex and sst/opencode. A crate-local notice in xai-grok-tools carries the license texts and an Apache §4(b) change notice.
    → Read both files before you let it run shell commands in a regulated repo

  5. Build gotchas
    The root Cargo.toml is generated — treat it as read-only and edit per-crate. protoc resolves through bin/protoc (a dotslash launcher) or falls back to $PROTOC. The toolchain is pinned by rust-toolchain.toml.
    → cargo check -p <crate>; full-workspace builds are slow
    → macOS and Linux are supported build hosts;

Full analysis: https://marktechpost.com/2026/07/15/spacexai-open-sources-grok-build-the-rust-agent-harness-tui-and-tool-layer-behind-its-coding-cli/

Technical details: https://x.ai/open-source

Github repo: https://github.com/xai-org/grok-build


r/AIDeveloperNews • • Mar 24 '26

I built an MCP server that gives Claude Code semantic code understanding — 4x faster, 50% cheaper on blast radius queries

17 Upvotes

I've been building Glyphh, an HDC (hyperdimensional computing) engine that encodes semantic relationships between files at index time. I wired it up as an MCP server for Claude Code and ran head-to-head comparisons on "blast radius" queries — the kind where you ask "If i edit this file, what breaks?"

The comparisons

Same repo (FastMCP), same model (Sonnet 4.6), same machine. One instance with Glyphh MCP enabled, one without.

Test 1: OAuth proxy (4 files + 4 test files at risk)

MetricGlyphhBare Claude Code
Tool calls136
API time16s1m 21s
Wall time24s2m 0s
Cost$0.16$0.28

Test 2: Dependency injection engine (64 importers across tools/resources/prompts)

MetricGlyphhBare Claude Code
Tool calls114
API time16s58s
Wall time25s1m 4s
Cost$0.17$0.23

Test 3: Auth orchestrator (43 importers, 8 expected files)

MetricGlyphhBare Claude Code
Tool calls132
API time14s1m 8s
Wall time1m 37s2m 1s
Cost$0.10$0.21

The pattern

Across all three tests:

  • 1 tool call vs 14–36. Without Glyphh, Claude spawns an Explore subagent that greps, globs, and reads files one by one to reconstruct the dependency graph. With Glyphh, it makes a single MCP call and gets back a ranked list of related files with similarity scores.

  • 50–79% less API time. The Explore agent burns Haiku tokens on dozens of file reads. Glyphh returns in ~14–16s every time.

  • 26–50% cheaper. And the bare version is using Haiku for the grunt work — if it were Sonnet all the way down, the gap would be wider.

  • Same or better answer quality. Both approaches identified the right files. Glyphh additionally returns similarity scores and top semantic tokens, which Claude uses to explain why each file is coupled — not just that it imports something.

How it works

At index time, Glyphh uses an LLM to encode semantic relationships between files into HDC (hyperdimensional computing) vectors. At query time, it's a dot product lookup — no tokens, no LLM calls, ~13ms.

The MCP server exposes a glyphh_related tool. Claude calls it with a file path, gets back ranked results, and reasons over them normally. Claude still does all the thinking — Glyphh just tells it where to look.

The way I think about it: Claude decides what to analyze. Glyphh decides where to look.

Why this matters for blast radius specifically

Grep can find direct imports. But semantic coupling — like a file that uses a DI pattern without importing the DI module directly — requires actually understanding the codebase. The Explore agent gets there eventually by reading enough files. Glyphh gets there in one call because the semantic relationship was encoded at index time.

This is the sweet spot. I'm not trying to beat Claude at search or general reasoning. I'm trying to skip the 14–36 tool calls it takes to build up context that could have been pre-computed.

Caveats

  • Full benchmark is available, model is still under development, using claude -p is not interactive and doesn't highlight the true gap.

  • There's an upfront indexing time cost to build HDC vectors. 1k files < 2 mins. Claude hooks and git ops keep the hdc repo in synch with changes.

  • For novel codebases you haven't indexed, the Explore agent is still the right tool.

  • Pure grep-solvable queries (find all uses of function X) won't see this improvement.

Repo: github.com/glyphh-ai/model-bfcl

Happy to answer questions about the approach or run other comparisons if people have suggestions.


r/AIDeveloperNews • • Mar 15 '26

LangChain’s Deep Agents looks like a real step beyond basic tool-calling agents

17 Upvotes

LLM + tools + prompting = “agent”

That works for short tasks. It usually breaks on longer, stateful workflows.

What stood out to me in LangChain Deep Agents is that it makes the missing runtime pieces default:

  • write_todos for planning

  • filesystem tools for context management

  • task for spawning subagents

  • memory across threads with LangGraph

  • LangGraph-native execution

That feels more practical than the usual agent demos, where everything gets crammed into one context window and falls apart once the task becomes multi-step.

The most important shift here is not the model. It’s the runtime structure.

Product featured: https://ainews.sh/ProductDetail?id=69b678fbb76e9548a7005f01

Repo: https://github.com/langchain-ai/deepagents

For people building agents in production:
Do you think frameworks like this are enough, or do serious systems still need custom orchestration early on?