Luc Stepniewski

Security and Network Engineer, Linux evangelist, Go, Python coder, AI explorer, Hermes agent fan and Chess player, I love knowledge and life!

[Peter Skøtt Pedersen @PeterSkott]

@steipete Using this to visualise the graphs https://t.co/RHJjr3TZaT

[Matt Pocock @mattpocockuk]

Some extremely smart ideas in here around:

1. Using /wayfinder as an orchestrator of custom skills
2. Using a multi-phase prototyping approach which zooms in on one part of the UI at a time - but in context

Give Will a follow, this is good shit

[cobi @cobi_bean]

https://t.co/lZTZL8nbX3

[Alex Finn @AlexFinn]

I did it. I figured out the perfect AI coding loop

It's called the Finn Loop and it's 100x'd my vibe code output while cutting the work I need to do down by 95%

ANYONE can implement this. It's super easy. Here's how it works:

1. 3 new skills inside your coding agent. /spec, /build, /review

2. You start out with /spec "your idea". The skill then asks you enough questions to fully understand your idea in detail then create a detailed spec inside Linear (amazing project management tool. Very generous free tier)

3. In another Codex/Claude Code session: you have a /build loop running. Once a spec is created, the /build skill picks it up and builds it out for you. Then advances the status of the issue in Linear

4. In another session, you have /review loop running. It picks up every issue that is built out then reviews it. Checks for security issues, optimization issues, then tests the code in its own browser, lays out test steps, takes screenshots, creates a PR, and puts it in its own vercel test sandbox for you to test it

5. The review loop then takes all of that and pings you in a channel in your favorite messaging service. I use Slack for this. It shows you the PR, gives you all the testing steps, and executive summary of the changes, and a link to the Vercel sandbox where you can test it

6. You go to the message in Slack, review the change, then send a rocket ship emoji as a reaction. This signals to the loop that the PR should be merged.

The only manual steps in this loop are you submitting an idea to your agent, and verifying the change at the end. Everything in between is automated in the loop.

Your vibe coding workflow today is hand holding your agent step by step on everything you build. You spend all day doing this.

Your vibe coding workflow when using the Finn Loop is you wake up, make a cup of coffee, give your agent a list of ideas, then come back at night and review all the changes. You're free to do whatever you want during the day.

Let me know if you want my full spec, build, and review skills. Will release them soon. Will also film a tutorial video on this.

There's also a ton more details I'll share shortly too, like the interface I built for monitoring all of this.

You also can probably just send this tweet to your agent and it will recreate the Finn loop for you.

Carve off some time and try this out today. I promise it will dramatically improve your workflow

[Teknium 🪽 @Teknium]

FYI you can make this your default message send mode (as opposed to interrupt or queue) in your config 👍👍

[Avi Chawla @_avichawla]

Stanford researchers did it again.

They just built the agent-native version of Git.

When an agent works on a longer task, the run builds up a lot of state.

This includes files edited/created, a dev server, a database, installed packages, KV cache, etc.

Say the agent is at step 10 and makes a mistake, maybe it misreads a traceback and rewrites a file that was actually fine.

The tests start failing, and the run goes off track, although everything through step eight was correct.

By default, the agent just tries to fix it, which creates more edits and tool calls. This burns more tokens and grows the context.

The other options are a person stepping in to redirect it or restarting the whole run from step one.

That's wasteful, because it pays for every model/tool call again and re-prefills the context. Moreover, since an agent's run is non-deterministic, it doesn't reproduce the same early steps anyway.

The reason it's hard to just jump back exactly to a previous correct step and resume from there is that the trajectory is only a message log.

It records what the agent said and which tools it called, but not the live state underneath.

That state includes things like memory, open file handles, child processes, installed packages, /tmp, and KV cache. None of that is in the log.

Git can version the files, but it doesn't snapshot the running process or the KV cache. Checking out step eight moves the files back, but the process is still sitting in step-ten memory with a cold cache.

Shepherd is a runtime layer by Stanford that records the run as a trace of typed events rather than a flat log.

Each agent-environment interaction becomes a commit, similar to Git, but it tracks the live run.

Its commit includes the agent process and the filesystem together, copy-on-write, so a branch carries the actual state and not just the files.

Going back to a previous step is then a single call that forks from that commit and continues from the exact state.

The copy-on-write fork is roughly five times faster than docker commit, and because the prompt prefix through step eight is unchanged, the KV cache is reused over 95% on replay, so early steps aren't reprocessed again.

Once the run can be forked, a meta-agent can sit on top and operate it. It watches the trace and reverts as soon as it looks wrong, before the bad write is committed.

In practice, it's just Python calling fork, replay, and revert on the trace, rather than a separate control plane wired into the harness.

Not everything is reversible though.

Files and sandbox changes undo themselves, but a database write has no automatic undo, so it needs a matching undo step set up in advance.

Something external, like a sent email or a real charge, can't be undone, so the supervisor's job there is to catch it before it fires.

They tested this on a few public benchmarks. On CooperBench, where two agents work on the same codebase, adding a live supervisor took the pair-coding pass rate from 28.8% to 54.7%.

It's still early and labeled alpha. The benefit mostly shows up when a run gets branched a lot over a heavy sandbox state, which is exactly where restarting wastes the most tokens and time.

If Git was made to make file changes reversible, Shepherd is trying to do the same thing for a live agent run.

Shepherd Repo: https://t.co/5e8W5oxY6F

(don't forget to star it ⭐ )

That said, Shepherd reverts a bad step inside a run. The harness around it, the prompts, tools, and checks the supervisor relies on, still drifts across runs as models and dependencies change.

Akshay wrote about making that harness repair itself, where a failing trace gets diagnosed, the fix is verified against the exact input that failed, and the failure is locked as a regression test so it can't recur.

Read it below.

[Luke The Dev @iamlukethedev]

Hidden Hermes gem: Credential Pooling

Most people run agents with one API key

Then they hit rate limits and wonder why everything slows down

Hermes can rotate across multiple credentials automaticaly

Add multiple keys for the same provider, choose a strategy, and let Hermes handle the rest

Strategies you can use:

fill_first
Use one key until it needs to move on

round_robin
Cycle evenly across keys. Great for load balancing

least_used
Pick the credential with the most remaining budget

random
Spread traffic with jitter so everything doesn’t hit at once

Example:

You have 2 OpenRouter keys

Instead of bottlenecking on one key, add both:

hermes auth add openrouter

Run it once per key

Then set in config file:

credential_pool_strategies:
openrouter: "round_robin"

Now requests rotate across credentials

More throughput
Less rate-limit pain
No manual key swapping

And the best part:

Hermes can fail over automatically

• 429 rate limit → cooldown, try the next key
• 402 quota exhausted → cooldown, rotate
• revoked token → mark dead and skip

Small config

Massive scaling unlock

[Granite @Granite0x]

He leads engineering on Gemini at Google.

instead of keeping his Claude setup private, he open-sourced it.

Addy Osmani. That Google: Chrome DevTools lead, "Learning JavaScript Design Patterns" author.

'agent-skills' - his personal loadout. Drop-in for any project.

68,925 stars. MIT.

→ https://t.co/n7NI3Sr7uu

bookmark it. This is how your Claude setup goes pro.

[Uzi @uzairansar]

Hermex is now opensource!

I was procrastinating on this for a while, but enough of you kept asking, so I finally got to it.

Just a little gift before we head out for the 4th of July weekend 😊

Let me know what y'all think, and let's make Hermex the best app for our Hermes agents!

[Nous Research @NousResearch]

Hermes Agent v0.18.0 - The Judgement Release

Changelog below:

[Meituan LongCat @Meituan_LongCat]

Introducing LongCat-2.0 🐱
1.6T parameters · MoE with ~48B active · 1M context
The full model behind Owl Alpha on @OpenRouter — now available.

Built for agentic coding from the ground up:
◆ LongCat Sparse Attention (LSA) — scales efficiently for 1M-context tokens
◆ Zero-Compute Experts — dynamic activation 33B–56B per token, zero wasted compute
◆ MOPD — three specialized expert groups (Agent / Reasoning / Interaction), gate-routed per task

How it stacks up:
→ Terminal-Bench 2.1: 70.8
→ SWE-bench Pro: 59.5 (GPT-5.5: 58.6)
→ SWE-bench Multilingual: 77.3
→ FORTE: 73.2 · RWSearch: 78.8 · BrowseComp: 79.9

📖 Tech Blog: https://t.co/4KrjyKiDBn
Try it across different scenarios 🧵👇

[Ed Andersen @edandersen]

Based China just released another open source coding AI LLM, "Ornith".

35B version runs on a large GPU locally and beats Qwen3.6 for my use case. The large 397B version benchmarks near Claude Opus 3.7...

If this keeps going it will crash the US economy lol

[Sudo su @sudoingX]

if you're just getting into local llms, do yourself a favor and start by building llama.cpp from source. not ollama, not lm studio.

build llama.cpp once, it's genuinely just a git clone and a make command with cuda on, and it clicks. you see the flags, you control the quant, you run any gguf on the planet, and llama-bench gives you real numbers instead of a vibe. when something's slow, you know why, and you can fix it.

ollama and lm studio are fine for "just chat with a model." but if you actually want to understand local inference, they're a ceiling, not a foundation. start one level deeper. it pays off every single day after.

[Ornith @ornith_]

Aloha! 🌺 Meet Ornith-1.0, a family of open-source LLMs specialized for agentic coding.

Ornith-1.0 spans the full parameter sizes including 9B Dense, 31B Dense, 35B MoE, and 397B MoE. It achieves state-of-the-art performance among open-source models of comparable size on coding benchmarks including:
✅Terminal-Bench 2.1(77.5)
✅SWE-Bench(82.4 on verified, 62.2 on pro, 78.9 on Multilingual)
✅NL2Repo(48.2)
✅SWE Atlas(41.2 on QnA, 42.6 RF, 39.1 TW)
✅ClawEval(77.1)

Post-trained on top of gemma4 and qwen3.5, Ornith-1.0 employs a novel self-improving training strategy in which reinforcement learning is used to generate not only solution rollouts, but also the task-specific scaffolds that drive those rollouts. By jointly optimizing the scaffold and the resulting solution, the model generate higher-quality solutions in agentic coding.😎

All models are released under the MIT license, enabling full commercial and research use.

📖Tech Blog: https://t.co/qT9N2HYWFn
🤗Huggingface: https://t.co/PRrwqjeBtM

[witcheer @witcheer]

a question that keeps coming up from people running Hermes agents: how do you coordinate more than one agent?

delegate_task, the kanban board, /goal, or build your own orchestrator on top? you rarely need your own layer. Hermes ships three primitives: match one to the shape of the work.

1 ~ delegate_task:

mid-task, the agent fans out sub-agents, each with its own goal, running in parallel (it nests, with a spawn cap so it can't run away). you watch them in the overlay, or replay the fan-out afterwards. reach for it when one task splits into chunks you want done at once

add --worktree and each agent gets its own git worktree, so parallel edits on one repo don't collide.

2 ~ hermes kanban:

a SQLite board shared across your profiles. the board claims each task atomically, tasks can depend on each other, and each runs in its own isolated workspace, with the dispatcher in the gateway. there's even a swarm graph: parallel workers, then a verifier, then a synthesizer.

this is the layer for multi-step work that outlives a single session.

3 ~ /goal:

type /goal and your objective, and the agent keeps taking the next step each turn until its judge calls the goal done, bounded by goals.max_turns in config.

reach for it when you want one session to keep working a single objective without re-prompting every turn.

build your own orchestrator only once you've outgrown all three.

[JUMPERZ @jumperz]

pro tip for Hermes /learn:

don’t treat it like dumping random memory, but create a space before it learns.

build a private channel and call it Learnables / learning room, whatever you like.

on discord, every topic becomes its own thread.
on Telegram, every topic becomes a forum topic or reply chain...

then drop one messy topic like: how should my agent handle Stripe disputes?

Hermes researches it first:

docs, examples, common mistakes, commands, links, and rough workflow.

then you add your own context for example ,make it founder-friendly , ignore the enterprise stuff ,add your Discord support flow, basically whatever actually fits your setup...

basically, you clean it up before telling it to learn.

only after that, say: learn this

now Hermes learns the reviewed version, not the messy first thought.

topic → research room → your taste → reusable workflow

that’s the real /learn loop and not just remember this but more like:

>research this
>organize it
>let me correct it
>then learn the cleaned version

that little research space before learning is where the skill gets good.. i put prompt of how to build this below..

/////////////

====== PROMPT========

Build a Learnables workflow for Hermes that works on either Discord or Telegram.

Goal:
Make /learn more useful by adding a research/review space before Hermes learns anything.

Core idea:
Users should not have to write perfect notes. They should drop a messy topic, let Hermes research it, add their own taste/context, then approve it with “learn this”.

Platform behavior:
If Discord:
- Create or use a private channel called #learnables.
- Every top-level message in #learnables becomes its own thread.
- Hermes replies inside the thread with a research/context pack.
- User reviews inside the thread.
- When user says “learn this”, Hermes learns from the whole thread.

If Telegram:
- If forum topics are enabled, create or use a Learnables forum group.
- Every new topic becomes its own forum topic.
- Hermes replies inside that topic with a research/context pack.
- User reviews inside the topic.
- When user says “learn this”, Hermes learns from the whole topic.
- If forum topics are not enabled, use reply chains:
- first message starts the learnable
- Hermes replies with a unique Learnable ID
- all replies to that message belong to that learnable
- “learn this” learns from that reply chain.

Research/context pack:
When a new topic is created, Hermes should not create a skill yet.
It should first gather:
- official docs and primary sources
- examples
- common mistakes
- useful commands
- links
- rough workflow
- what to ignore
- open questions for the user

Review step:
The user can add:
- their preferred tone
- constraints
- examples
- bad examples
- project-specific context
- what to keep
- what to remove

Learning step:
Only after the user explicitly says:
- learn this
- save this
- turn this into a workflow
- make this reusable

Then Hermes turns the reviewed thread/topic/reply chain into a reusable learned workflow.

Final output after learning:
- short title
- what Hermes learned
- when to reuse it
- example trigger phrases
- source links used
- any user-specific preferences captured

Important rules:
- One topic per thread/topic/reply chain.
- Do not learn from the first messy message.
- Research first, learn later.
- Prefer official/primary sources.
- Keep it practical, not academic.
- Never overwrite existing learned workflows without asking.
- Confirm before saving if the context is unclear.

Example:
User posts:
how should my agent handle Stripe disputes?

Hermes creates a research room and gathers:
- Stripe dispute docs
- evidence submission examples
- common SaaS mistakes
- recommended support flow
- questions for the user

User replies:
make it founder-friendly
ignore enterprise stuff
add our Discord support flow

User says:
learn this

Hermes saves the cleaned workflow, not the messy first thought.

===== END OF PROMPT======

[Nous Research @NousResearch]

Your Hermes Agent can now adopt an animated pet: a small sprite that reacts to what the agent is doing (idle, running a tool, thinking, waiting, finishing, failing) in the GUI or TUI.

You have nearly 3000 pets to choose from via the petdex gallery, or you can submit your own.

[witcheer @witcheer]

decided to write the full start-to-finish guide to running Hermes Agent 24/7:

copy-paste commands, every one tested on real hardware, on a cheap VPS or a Mac Mini. if you have been meaning to start, this is your on-ramp.

I will be more than happy to help if you still struggle on a specific part. please let me know!

[Kyle Hessling @KyleHessling1]

Morning y'all!

We've released Qwopus 3.6 27B-Coder-Compat with some compatibility fixes for various harnesses!

This version should exhibit significantly less looping behavior across more harnesses. Thinking stability has also been improved, where many other harnesses were having issues with it enabled!

Still run temp high and make sure your harness isn't overriding the temp setting of your server. You preferably want it running between .85 and 1, and many harnesses will push low defaults like .1 even if you have your server set up properly. In which case, you can change the harness-specific settings to match.

I tested it in Claude Code and made a fun mario style side scroller game! I definitely think Claude's enormous system prompt adds some capability too, as it nearly one-shot this game, and I just turned it a couple more times to add some stuff I thought of while testing it. Game link in comments!

Qwopus even generated music and audio for this one, and I think it did a really excellent job! Crazy that those additions would've taken so long to add to a game mere years ago, and a local model just generated and applied them natively!

The ability to make feature filled HTML games locally on a 5090 with high speed iterattion is an excellent showcase for local models! It's also addictive to keep adding game mechanics and levels as you think of them. The stability is incredible; I never had any DOA outputs. All changes played fine on the first turn!

So what's stopping you from publishing a game to the App Store with Qwopus, or any of these local models? They're more than capable of doing it! You could go crazy with looped iteration and incredible depth as a solo dev! Send me links if you build something, I'd love to check it out!

If you were having issues before with looping in your harness or use case, please give this new version with the fixes applied a try and let us know what you think!

Always a pleasure, my friends! Have an excellent Monday!

35B-coder MOE will be launching soon, too!
https://t.co/7dwHdgVswN

[YanXbt @IBuzovskyi]

https://t.co/VxyyeQCimO