r/ZaiGLM

I built a small MCP project and would love feedback from people using OpenCode, DeepSeek, GLM/Z.ai models, or other coding agents.

https://github.com/yurilopes/Copilot-Tools-Gateway

The basic idea is: keep your main coding model as the main agent, but let it call Microsoft Copilot as an auxiliary tool when it needs capabilities the model/tooling may not have, like vision, screenshot understanding, image generation, or document/file-assisted questions.

This is especially useful with models like GLM-5.2 or DeepSeek, where the coding/reasoning may be strong, but the surrounding tool stack may not always expose vision or document understanding.

The gateway exposes Copilot through MCP tools, so an agent like OpenCode can call things like chat, image analysis, image generation, and file-assisted questions using your own local Microsoft account session.

It is unofficial and not affiliated with Microsoft.

I would really appreciate people testing it and telling me what feels good, what feels awkward, what breaks, and what would make it more useful for real agentic coding workflows.

so recently i bought clinepass to give it a try. I used GLM 5.2 as the main workhorse and got solid usage for the price (got it at $1.99).

I use GPT 5.5 in codex as the planner and reviewer. it writes the proposal and execution plan, then GLM 5.2 acts as the implementer.

the result was quite solid. I got two infra refactors done in a single 5-hour session. it consumed around 61M tokens for that one session. the session itself used around 20% of the monthly limit. I started at 3%, based on the image. so if we estimate from that, the monthly limit would be gone in about 5-6 sessions.

well, I can’t complain since it only cost $1.99. it’s good considering the price.

as for GLM 5.2 itself, it literally blew my mind, lol. solid executor. I had codex review the code generated by GLM, and it couldn’t find any major issues. everything aligned with the plan codex gave.

so I think this is a pretty comfortable workflow for people looking for an affordable setup: a $20 codex subscription for planning, review, and the hardest tasks, then a cheaper open-model subscription like cline or opencode for execution.

btw, I tested it on my side project: an AI token usage tracker. it’s local-first and already supports most coding agents like codex, claude code, opencode, antigravity, cline, and zcode.

if you want to give it a try:
https://github.com/fikrilal/burnly

Video source

Hey guys and gals.

I built a tool (https://www.typeui.sh/docs/guides/hermes) that helps you let your Hermes agents build better UI by using design skills that lets you build UI in a certain style.

It automatically installs a collection of markdown files that will:

• set the style of the UI (choose from here https://www.typeui.sh/design-skills)
• installs a UI/UX fundamentals skill file

And then websites generated by your Hermes agent will look like one of the skills that you select from the website.

It's also on Github:

https://github.com/bergside/typeui

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.

Everyday for the last three weeks, I wake up 5 minutes before the supposed 'restock', which is 5 AM my time. Every day, 3 minutes before restock time, it says "too many people are buying", and continues that for anywhere between 8-31 minutes before hitting me with the temporarily sold out.

I've verified my passport and chinese phone number - wondering if even after that anyone has found any useful services as an alternative. I'm really hesitant to use smaller companies, and prefer well known brands. Someone mentioned xfyun, I've heard of 硅基流动, but if anyone has any suggestions I'm all ears.