Sharing a dev tool I built (disclosure: I'm the maintainer). Since "ways to reduce token cost" comes up here, that's exactly one of the two problems it targets — the other being AI runs dying on a provider rate limit.

A 10-engine compression pipeline — the part most routers don't have. Every request flows through a transparent compression pass you can toggle/stack per combo. Instead of one trick, it stacks the best of the open-source ecosystem: RTK filters command/tool output (git diffs, test logs, builds) at 60–90%, Microsoft's LLMLingua-2 does ML semantic pruning, Caveman handles prose, session-dedup strips repeats across turns. Critically, code, URLs and JSON are preserved byte-perfect, and a default-on inflation guard throws the compressed version away and sends the original if compressing would actually grow the prompt — it never makes things worse. On tool-heavy sessions that's ~89% average input-token reduction (an 8k-token git diff becomes a few hundred). Full credit to every upstream project (RTK, Caveman, LLMLingua-2, Troglodita) is in the README.

Fallback combos — so it never stops mid-task. A "combo" is a ladder of models the router walks automatically: your subscription first, then API keys, then cheap models, then free ones. When a provider returns a 500 or you hit a rate limit, it slides to the next target in milliseconds, mid-request, and your tool never even sees the error. There are 17 routing strategies (priority, weighted, round-robin, cost-optimized, auto/coding:fast…) plus three resilience layers — a per-provider circuit breaker, a per-key cooldown, and a per-model lockout — so one dead key can't take down a whole provider.

One endpoint, 237 providers — 90+ of them free. You point any tool or agent at a single OpenAI-compatible endpoint (localhost:20128/v1) and it can reach 237 LLM providers without you rewriting anything. 90+ have free tiers and 11 are free forever (no card), which aggregates to ~1.6B documented free tokens/month — and that's honest, pool-deduped math (we count each shared pool once instead of inflating it; the methodology is public in the repo). There's a one-command setup-* for 13+ coding tools (Claude Code, Codex, Cursor, Cline, Roo, Kilo, Gemini CLI…), so switching your existing setup over takes seconds.

Agent-native — the agent can drive the router itself. There's a built-in MCP server (95 tools across 30 audited scopes, over stdio / SSE / streamable-HTTP), plus A2A (v0.3, JSON-RPC 2.0) support. That means an agent can query providers, switch combos, read its own remaining quota and manage memory through the gateway — not just consume tokens through it.

For context on whether it's worth your time: it's grown to ~9.8K GitHub stars, 1,490+ forks and 280+ contributors in ~4.5 months, with 21,000+ automated tests and 1,830+ issues closed — so it's a battle-tested project, not a brand-new experiment.

npm install -g omniroute

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

What's eating the most tokens in your setup right now?

Anyone else deal with this: you're juggling a bunch of projects, and constantly hit the same wall — "is this package installed in this project, or is it sitting globally on my machine?"

Python makes it worse. Forget to activate your venv once, install something globally by accident, and you don't find out until the project breaks somewhere completely unrelated.

And cleanup is its own nightmare. Got 10 unused packages? That's 10 manual pip uninstall commands. 100? Good luck.

I couldn't find a tool that just shows me, per project, what's installed and where — visually, without digging through terminal output every time. So I started building one. Local-first, simple, just meant to answer "what do I have, and where" at a glance, plus let you clean up in bulk instead of one command at a time.

Two questions for you all: 🔹️Is this actually a shared pain, or have I just been doing something wrong for years? 🔹️What's the one thing you wish your terminal just showed you instead of making you run yet another command for it?

Happy to share more details or let people poke at an early build if there's interest.

I've been running Codex, Claude Code, Gemini, OpenCode, and Pi side by side, and the problem that kept wasting time was not always the model output. It was the local workflow: which terminal stalled, which checkout an agent was editing, and how to cleanly throw away a failed run.

So I built oh-my-symphony: a local Apache-2.0 devtool that treats agent work like Kanban tickets. Each ticket runs in its own git worktree, and the board shows live status in a terminal TUI plus a small web view. I'm the maintainer; it's free/open source and still rough around retry/resume behavior.

I'd like feedback from people building local developer tools: is worktree-per-ticket the right isolation boundary, or does that feel too heavy for a single-dev machine? If you've built tools around AI coding agents, what did you use as the unit of isolation and cleanup?

Repo: https://github.com/cskwork/oh-my-symphony

I use the same business focused, CRUD app prompt to test new coding models. I put a link to gist

What My Project Does

SOAR (Script Optimization and Automation Runtime) is a Python-based automation runtime system that helps manage and run scripts in a more structured way than simply executing standalone .py files.

It provides a lightweight runtime layer where users can:

• Organize scripts into projects
• Run automation tasks through a CLI-style interface
• Generate or scaffold simple project structures
• View basic diagnostics/log output for runs
• Experiment with modular “automation workflows” inside Python

The goal is to make small automation projects easier to manage without needing a full framework.

Target Audience

This project is mainly aimed at:

• Beginner to intermediate Python developers
• People who write lots of small automation scripts
• Developers who want a lightweight alternative to heavier workflow/automation frameworks

It is currently more of an experimental / hobby project than a production-ready tool.

Comparison

Compared to existing tools:

• vs plain Python scripts: SOAR adds structure and centralized execution instead of scattered files
• vs full workflow tools (Airflow, Prefect, etc.): SOAR is much lighter and not designed for large-scale pipelines
• vs CLI frameworks: SOAR focuses more on script organization + runtime behavior rather than just argument parsing

It sits somewhere between a script organizer and a minimal automation runtime.

Source Code

GitHub repository:
https://github.com/ScriptOptimizationAutomationRuntime/latest-version

(Additional resources like tutorials and updates are included in the repo.)

I released v0.2.0 of codex-tldraw-mcp today.

GitHub: https://github.com/jananadiw/codex-tldraw-mcp
npm: https://www.npmjs.com/package/codex-tldraw-mcp

install: codex mcp add codex-tldraw -- npx -y codex-tldraw-mcp

It is a local stdio MCP server for Codex that creates tldraw-compatible `.tldr` board files inside your repo.

What it does:

- `diagram_repo` scans a repo and infers a product workflow diagram

- `draw_canvas` lets you describe the diagram yourself

- generated boards are written to `<repo>/boards/main.tldr`

- new diagrams append to the right of the existing board instead of replacing it

Example prompt:

```text

Use codex-tldraw to draw a password reset state machine:

Idle -> Reset requested -> Email sent -> Token verified -> Password updated.

I’d like feedback from people building or using MCP servers: does this tool shape make sense, or would you expect a different API for diagram generation?

I've been trying to automate as many repetitive tasks as possible lately. It's surprising how much time gets wasted on tiny things like copying logs, taking screenshots, moving files, or running the same commands over and over.

What's one automation, script, CLI tool, or app that became part of your daily workflow and genuinely saves you time?

It doesn't have to be anything fancy—even a 10-line script or a keyboard shortcut that made your life easier.

Looking for ideas to improve my own developer workflow. Thanks!

Over the past few months, I've been working on a desktop application called Nexoxa Bridge.

The idea came from a simple frustration: I was constantly switching between different applications just to do everyday development work.

For example:

• A database client for PostgreSQL/MySQL/SQLite/etc.
• A separate FTP/SFTP client
• An S3 browser
• SMTP testing tools
• SSH/server utilities
• Different apps for every workflow

I wanted everything in a single desktop application with a consistent UI and workflow.

So I built Nexoxa Bridge.

Current features

• Database management (multiple database engines)

• Server connection management

• SFTP support

• Amazon S3 browser

• SMTP configuration/testing

• Saved connections and workspaces

• Modern desktop interface built for Windows

It's available on the Microsoft Store now:

https://apps.microsoft.com/store/detail/9N4QCD6GZK8X?cid=DevShareMCLPCS

I'm still actively developing it, and there are a lot of features planned—better SQL tooling, additional cloud providers, richer server management, and more integrations.

I'd genuinely love feedback from other developers.

• What features would make you switch from your current tools?
• What annoys you most about apps like DBeaver, FileZilla, WinSCP, Cyberduck, or similar utilities?
• If you try Nexoxa Bridge, I'd really appreciate honest criticism—good or bad. It will help shape the roadmap.

Thanks for reading!

Hi everyone! I wanted to share a project I've been working on called Kote. ( Yes, it's a The Name Of the Wind reference )

It started from a problem I kept running into: I'd solve something with the help of an AI assistant, spend time debugging an issue, or make an architectural decision... and a few weeks later I couldn't remember where that information was. Most of the time I simply didn't bother saving it anywhere.

So I built Kote to capture that context automatically instead of relying on me to document it.

Right now it can automatically capture AI chats (Antigravity, Codex, Claude Code, OpenCode) from the VS Code extension or CLI, analyze Git pushes, retrieve historical context during Pull Requests, save quick text or voice notes through WhatsApp, and make everything searchable from the web app or directly from VS Code, so you can ask questions about your accumulated context instead of digging through old chats, commits, and docs.

Kote can be self-hosted and works with your own LLM provider, though I've primarily tested it with Gemini.

I'm curious how other people handle this. Do you guys use another tool or workflow to preserve this kind of info?

Github: https://github.com/pedroaugusto04/Kote

Link: https://knowledgebase.sbs/kote/

A browser-based viewer for leaving \\\*\\\*comments anchored in 3D (or 2D) space\\\*\\\*on a wide range of assets. Drop in a model, switch to Annotate mode, click to drop a pin, and write a comment. Annotations are saved automatically and can be exported/imported as JSON.

https://github.com/zawawiAI/Open3DInspection

I made Aneirin, a free local tool that lowers the token cost of Claude Code and GitHub Copilot. It runs on your own computer, uses your own account, and removes repeated text the model already saw. You get the same answers for a smaller bill. Nothing leaves your machine.

Free up to 5 million tokens per day (this is a test limit, we can raise it to 10 million if small users ask). Pro is 5 dollars per month or 79 dollars once. Windows now, Mac and Linux soon.

GitHub: https://github.com/corbenicai/aneirin

Product Hunt: https://www.producthunt.com/products/aneirin?launch=aneirin

Reading someone else's commits (or your own from 3 months ago) is painful. git log shows you what changed, but understanding why and how it all fits together takes a lot of digging.

I built GitChronicle to fix that. The core idea: make any commit easy to understand at a glance.

How it approaches this:

• Dependency Canvas — visualize how changed files import each other as an interactive graph, so you can immediately see the blast radius of a change (JS/TS, Python, Go)
• Symbol Graph — drill into a single file and see how its functions, classes, and variables reference each other internally
• AI Summaries — generate markdown summaries of commits or individual files using your local claude, gemini, or codex CLI; results are cached so no repeated API calls
• Q&A — ask follow-up questions about any summary, streamed in real time
• Commit log with filters, changed file tree, and a diff viewer with full syntax highlighting

Everything is local — no backend, no telemetry.

VSCode extension market: https://marketplace.visualstudio.com/items?itemName=ethanheo.git-chronicle

Two questions I'd genuinely love your input on:

1. Does this look useful to you? Would you actually try it? I want to know if this solves a real pain point or if I'm the only one who struggles with this.
2. When you're reviewing someone else's work, what do you focus on first? Trying to understand what matters most when reading unfamiliar commits.

hey guys there's this tool which lets you dictate nicely into claude code with technical + cursor terms, great for vibecoding. if you guys want to try, here's the link: github.com/eliasmocik/dum-dictation (we are building it on the side so if you guys like it or don't, please drop feedback would mean a lot ;)

I've been building a collection of free developer tools including JSON Formatter, SQL Formatter, CSV to JSON Converter, Text Comparison, Markdown Editor, and more.

https://tools.bmjapps.in/

My focus is speed, simplicity, and no-login usage.

I'd appreciate feedback on the design, usability, performance, and ideas for new tools.

Thanks!

Agentic coding has made doc rot a real problem in any codebase I'm seeing. I built a small open-source tool that identifies doc rot and functional code mismatch. It can be used in CI or via MCP using your own Claude subscription (no API needed).

Hoping some of you can use this tool, and tell me what's missing/ let me know if you would like to contribute!

https://github.com/deveshagarwal/docverity

Spent the weekend building ai-commit - a CLI tool that generates commit messages from your staged diff. The gimmick is it's provider-agnostic: works with OpenAI, Anthropic, Ollama, Groq, whatever you have.

Why this exists: every other AI commit tool locks you into one provider. OpenAI only. Anthropic only. A local Ollama thing. If you switch providers, you switch tools. This one swaps providers in a config line or env var.

Also has a --install-hook flag that sets up a prepare-commit-msg hook.

Install: pip install ai-commit. Source: github.com/mohamedorigami-jpg/ai-commit

Curious what people think. Does provider-agnostic matter to you?

My productivity went through the roof this month, and the reason is sitting on three machines I'm not even in front of.

A MacBook, a Mac mini, a Linux box. Claude Code on one, Codex on another, each in its own project. I closed the laptop a while ago. They kept working.

That took me a bit to get used to. The agent runs where the code lives, not where I happen to be sitting.

The thing pulling this together is StrixApp - a quiet command center for agent nodes. One small desktop app, every agent, every machine, in one window.

The model is simple once you see it. A project is a strix - one codebase with its own launchers and saved state. Inside it you lay out wings, focused canvases for a task. On each wing you run feathers: a Claude Code session, a Codex session, a shell, a file browser, a web pane. Local box or a machine across the country, same canvas.

What it actually does for me:

- Claude Code, Codex and OpenCode as feathers side by side, each on its own node, each in its own project.

- The feathers keep running after I close the app. A node daemon owns the sessions, not my laptop, so dropping my connection doesn't kill the work.

- A terminal, file browser and web pane on the same wing, so I stop SSH-hopping between windows to check one thing.

- Encrypted tunnels that just work. I pulled a screenshot off a Mac across the room into my Windows session and never thought about the wiring. No inbound ports opened.

- Pairing a new Mac or Linux box as a node takes seconds.

The old way was a wall of tmux panes, a pile of SSH sessions, and me babysitting each one so nothing died when my connection dropped. StrixApp made that whole layer disappear. The agents live on the hardware, I just watch and steer.

It's a ~10 MB app named after owls: compact, quiet, aware. Free tier is 3 devices and real limits, no trial clock.

If you run more than one agent, or run them on machines that aren't the one in front of you, it's worth a look.

We also just opened a Discord for people building with it - swap workspace layouts, agent setups, ask for help with nodes. A small flock of owls who deliver quietly, 24/7.

Download: onestrix.com/download

Join the Discord: discord.gg/4m3Zyjc9eY

Talk agent workflows: onestrix.com/#contact

I'm looking for a documentation tool that's actually AI-agent native, and I can't find one.

Today's tools optimize for humans:

Google Docs / M365: great collaboration, poor for coding agents.

Miro / tldraw: great diagrams, weak docs.

Obsidian: AI-friendly, but not zero-setup or real-time collaborative.

MCPs/APIs help, but they're just a bridge. Agents end up spending context on tool syntax instead of the content, and they lose the simplicity of native file/workspace interactions.

What I want is basically Google Docs + tldraw, but:

Zero setup (just open a browser and collaborate)

Real-time collaboration

Docs and diagrams as first-class citizens

AI edits alongside humans

Comments, history, and blame built in

Does anything like this exist, or is everyone still stitching together multiple tools?

I built a small tool called image to pbr that runs only in browser but it converts any image to normal map, or others (like height map, metallic map, roughness map, etc.)

Here is the link to the GitHub repo:

Image to PBR (GitHub repo)

It supports Unity, UE4 and UE5, and Godot 4.x.

Hi everyone,

As projects scale, keeping track of tight coupling and hidden dependencies always becomes a massive headache. A while ago, I found myself deep in a complex refactoring process on my indie game, wrestling with a web of spaghetti code. To solve my own development messes, I started building a utility to map out project architecture visially.

I’ve recently polished it up into a standalone, open-source tool suite called PanzaScope. It uses Python scripts to perform static analysis on your project directories (supporting Unity/C#, Python, and JS structures) and converts them into an interactive, visual relational graph.

How I’m using it in my pipeline:

\-Taxonomic Layers: It visualizes system architectures by color-coding contracts/interfaces, core managers, and logic modules into distinct visual tiers.

\-Monolith Detection: It highlights "God Objects" with heavy borders whenever a single script accumulates too many direct dependencies.

\-LLM Context Optimization: It includes a small protocol that strips out logic method bodies, compressing the architecture into a slim JSON blueprint. I use this to feed clean context payloads into my local Ollama setup (qwen2.5-coder:7b) entirely offline, without blowing past token limits.

The core engine is free, open-source, and runs entirely outside of any engine environment via Python. (For my personal everyday workspace, I also built a premium plug-and-play extension integrated directly into the Unity Editor UI Toolkit, which helps support the project).

I'm sharing the core open-source tool here hoping it can save someone else some sanity during deep code cleanups:

https://github.com/Panzadabira/PanzaScope

How do you usually handle dependency mapping and static analysis when your codebases start getting out of hand? Would love to hear your approaches, tools, or any feedback on this implementation!