r/OnlyAICoding

I built a harness for myself. It runs on my own machine. Its beautiful, fast, and built for professional work (I use it for my job).

The aesthetics and design was important to me, had to be easy to use, informative, feature rich but not bloated.

Features I built into it:

• Runs locally in a browser: remote-accessible from any device with a browser, full mobile UI, installable as a home-screen app in Android.
• Tabs: Multiple sessions open at once, and sessions keep running even if I close the browser
• Prebuilt AGENTS.md per project type: Coding, Writing, Business, Legal, General
• Epic mode: Projects too big for one conversation get a persistent spec, task list, and state that future sessions pick up
• Persistent memory: browse, edit, or delete every memory, and see exactly what got recalled into any chat
• Nightly worker agents: Automated nightly code review + fixer agents lay out verified, one-click fixes every morning
• Private web search & deep research: Self-hosted search engine, cited reports (Crawl4AI).
• Independent reviewer agent: A clean-context critique of code, docs, or writing, instead of the model grading its own work
• Chats & projects: Quick chats each get an isolated folder with full tool access; serious work lives in project workspaces
• Handles every file type, both ways: Reads and authors PDF, Word, Excel, PowerPoint, images, charts; plus skills and saved prompts with fill-in variables
• Voice both ways: Local Whisper dictation and read-aloud replies; no audio leaves the machine

Nice touches: full system terminal access, a ⌘K command palette with cross-project search, a usage dashboard that counts every token, live system status, a real note-taking app, plan mode, light/dark themes, native notifications when a turn finishes, and hourly encrypted backups.

My goal with this post is to inspire others to build their own harness for themselves, its actually tons of fun! Like building out your workshop or garage the way you want to help you create, repair, & experiment on things.

Work in progress, solo developer, so the usual caveats apply. I want to share the project but mostly the workflow question.

I'm building Yon, a programming language with a real type-checker (dependent types, identity/path types, a small proof kernel) that compiles to native code through MLIR and LLVM. I use AI as a pair formalizing logic and math solutions, generating code, exploring designs, drafting docs. The hard problem isn't getting the AI to write code. It's that in a system like this, AI-generated code can be plausibly wrong: it compiles, it looks right, and it silently makes the type-checker accept things it shouldn't. In a proof kernel that's the worst failure mode, because the whole point is to reject false statements.

So the workflow I've settled into is built around not trusting any single pass, AI-written or mine:

• Every claim gets verified against the code, never from memory or from what the AI "says" it did. File and line, or it didn't happen.
• An adversarial audit pass where I go hunting for false-accepts in the checker. Recent ones I found and closed: the universe-equality check was a tautology (it accepted Type_0 == Type_5), and a naturality check reported a false "proven" from key aliasing. Neither was a crash. Both were the system claiming something untrue. No amount of "the AI wrote it and it compiled" catches these; only reading it does.
• A regression suite that runs the whole pipeline end to end on every example, on Linux x86-64 and macOS Apple Silicon, plus kernel oracles. AI slop doesn't survive a regression suite. That's the filter.

The takeaway I'd offer the sub: AI is genuinely fundamental for a project this size, but only if you treat its output as a suspect that has to earn trust through mechanical verification, exactly like you'd treat your own tired 2am code. The leverage is real; the guardrails are non-negotiable.

Where it's at: this is the current line of work. Version coming in the next stretch, and I'm rewriting the site and the documentation, plus a proper illustrative project. Repo's open if anyone wants to look at how the verification side is wired.

Repository: https://github.com/yon-language/yon

Website: https://yon-lang.org/

Subreddit: r/YonLang

Builders-welcome post with the substance up front (disclosure: I'm the maintainer). OmniRoute is a free, MIT, self-hosted AI gateway — one OpenAI-compatible endpoint over 237 providers — built around two problems: runs dying on a provider 429, and tokens bleeding on tool/log output.

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.

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.

Fusion — an ensemble mode for the hard steps. Beyond simple routing, there's a fusion strategy that fans a single prompt out to a panel of different models in parallel and then has a judge model synthesize one best answer (mixture-of-agents, built in). It's cost-aware, so easy turns stay on one fast model and it only fuses when the step is worth it.

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.

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.

It's 100% local (zero telemetry, AES-256-GCM at rest), MIT-licensed, has a prompt-injection guard on every LLM route, opt-in memory, and runs on npm, Docker, desktop or your phone via Termux.

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 · Site: https://omniroute.online

Would value a critique of the routing/compression architecture from this crowd.

Hey everyone!
I'd like to share a project I've been working on, it's called Orin and it's a coding agent.

I use coding agents constantly, and at some point I realized I had basically no idea what was happening between me hitting enter and code showing up.

Also I was tired of building apps I wasn't able to really debug because I didn't know how they were being built in the first place so I got busy studying: read a bunch of articles, still felt like a black box, so I just tried to build one.

Couple things worth saying before anyone digs in:

It's mostly AI-written code, no point in hiding that, but I don't think "written by AI" and "sloppy" have to go together.

I try to run all my projects in the most professional way I know of, following actual SDLC practices: spec first, then an issue, then the implementation, then a real PR review before anything merges, not vibe-coding where you just accept every diff.

Whether that shows in the actual code is for other people to judge, not me.

Also this isn't some original idea I came up with: I cloned and read through pi.dev, nanocoder, and opencode as primary references (and skimmed Cline/Kilo Code for patterns), and basically tried to take what made sense to me from each and put it into one implementation.

My whole idea was try and build something that took the best from each to make a coding agent that would perform well. I plan to benchmark it on SWE-bench Verified sooner or later, but I don't think it's ready just yet: there are rough edges and bugs, but its usable.

Some of the actual implementation stuff, for anyone who cares about those rather than the pitch:

• The loop is just: stream a response from the provider, push it to message history, if there are tool calls run them, push the results back, repeat until there's nothing left to call.
• The loop is completely headless — it doesn't touch the terminal, it just emits events. The TUI (SolidJS on top of OpenTUI, just like opencode) is a separate subscriber to those events. You could swap in a totally different frontend without touching the loop at all.
• Another thing I got from OpenCode are edits: they go through a fuzzy replacer chain, not a single exact string match — if the model's oldText is off by whitespace or indentation, it falls through a chain of matchers before giving up. I had never thought about this and can confirm it's the kind of thing you don't appreciate until you actually try to implement it.
• There's a model routing mechanism that switches different models based on what the agent has to do:
  • explore runs on a cheap/fast model by default,
  • implement on a code-tuned model,
  • review on the main model.
• Another thing I borrowed from the web is a delegate_read tool that lets the main agent hand off read-heavy grunt work (scanning a big file, summarizing logs) to a cheap model so that content never bloats the main context.
  • It's basically a one off LLM call that only returns a distilled summary, seems dumb but works surprisingly well with capable models like Claude who know exactly what to look for and delegate super well to other agents.
• Tool selection isn't a static allow-list. Every turn runs a BM25 retrieval pass over the full tool catalog (including MCP tools) via a super cool library called Ratel, so the model only ever sees the tools relevant to what it's doing in that specific turn instead of the whole catalog every time. There's even an A/B flag to compare tool_pool=ratel vs tool_pool=default in your own telemetry to see if it even makes a difference (similar to how rtk gain works).
• Every file write gets snapshotted into a shadow git history before it happens, including stuff done through raw bash — allowing the agent to have a proper /undo /redo command.
• When I implemented subagents I wanted to explore different isolation mechanisms and ended up with 3 different ones you can configure yourself:
  • shared (edits land on the main working tree, safe because they run serially),
  • worktree (isolated branch)
  • sandbox (a real E2B cloud VM, edits get thrown away on dispose — for code you don't trust at all).
  • The lead model can escalate isolation for a given task but never go below the configured floor.
• I implemented hooks borrowing from nanocoder and opencode. This allows the agent to be expanded by third party code and I bundled some sensible defaults:
  • there's a before_tool hook that rewrites bash commands through rtk so that command output gets compressed before it ever reaches the model.
• In my daily work I build AI agents and vibe coded internal tools for my company and after a while I saw how much telemetry is crucial for debugging and actually understanding agent behaviour, so I decided that my agent would ship native OTLP tracing by default.
  • This means that by adding just one environment variable you can see full traces in your telemetry platform (Langfuse, Tempo, Jaeger, whatever you like) out of the box.
• Orin is also provider-agnostic (currently supports OpenRouter, OpenAI, Anthropic, OpenCode Go/Zen and Regolo if you want an EU-hosted option) — switching provider or model happens at runtime through a provider registry, no restart needed.

None of this is groundbreaking, it's just what I landed on after reading other people's code and deciding what to keep.

Try it:

git clone https://github.com/thetombrider/coding_agent.git

cd coding_agent

./install.sh

orin

There's also a deepwiki writeup if you want the architecture without reading source: https://deepwiki.com/thetombrider/coding_agent

I would really appreciate feedback in any shape or form. I'm learning and sharing my journey, hope it helps someone.

I've been learning AI engineering by building instead of just watching tutorials.

To push myself beyond the basics, I started building an AI Code Review Agent. The goal wasn't to create a polished product—it was to force myself to understand how these systems actually work.

Some of the concepts I ended up learning along the way:

• Retrieval-Augmented Generation (RAG)
• Embeddings and vector search
• ReAct-based agent workflows
• LLM-powered code analysis
• GitHub integrations

One thing I learned quickly is that getting an LLM to answer questions isn't the hard part. Making retrieval reliable, giving the agent the right context, and designing good workflows takes much more iteration than I initially expected.

The project is open source and still a work in progress, with plenty of room for improvement as I continue building and learning.

Repository: https://github.com/RishabhhG/codereview-agent
Linkedin : https://www.linkedin.com/in/rishabh-guptaaa/

If anyone wants to try it out, use it, or contribute, I'd really appreciate the feedback. I'm also happy to discuss the architecture, implementation decisions, or hear suggestions for improving the agent.

​

Link of repo:

https://GitHub.com/coder-arnav66/Arnav-Python-Projects

DS had finished a prompt and I was like how bad is it?

Rare user win. Thank you team DeepSeek 🙏

I still I’m just

Thankful