Video yükleniyor...

Video Yüklenemedi

Ana Sayfaya Dön

HarnessRouter just open sourced a plug-and-play infrastructure layer that runs Codex, Claude Code, Hermes, DeepSeek Harness, System One powered by Jev and 9 more agent harnesses under one interface, with a Unified Harness Protocol and OpenAI Responses-compatible API. → Bring Jev into the same product already using Codex or...

52,014 görüntüleme • 1 ay önce •via X (Twitter)

10 Yorum

Jatin Garg profil fotoğrafı
Jatin Garg1 ay önce

The infrastructure layer is the unlock here. Routing between models stops being a research problem when the plumbing is already built.

Meta Racing profil fotoğrafı
Meta Racing1 ay önce

it's yapping time

Defi_Noal profil fotoğrafı
Defi_Noal1 ay önce

finally we get a common standard for this

Neuni United profil fotoğrafı
Neuni United1 ay önce

Everything in life is temporary. Be grateful in the good times and stay hopeful in the hard ones. Nothing lasts forever

why profil fotoğrafı
why1 ay önce

One interface across Codex, Claude Code, DeepSeek Harness, and the rest is a pretty useful abstraction for agent tooling.

스카이 DeFi profil fotoğrafı
스카이 DeFi1 ay önce

Unified Harness Protocol is the real breakthrough here, standardizing the mess is overdue

Miano profil fotoğrafı
Miano1 ay önce

One interface for many agent harnesses feels like the missing layer between model choice and reliable execution. The protocol matters more than the novelty of another wrapper.

Macro Bombastic profil fotoğrafı
Macro Bombastic1 ay önce

tbh the unified protocol is what I care about most here

tim777 profil fotoğrafı
tim7771 ay önce

one interface, twelve harnesses. the router layer is where the margin quietly moves.

Deep profil fotoğrafı
Deep1 ay önce

one interface for every harness is the exact thing i keep rebuilding by hand. nice to see it open sourced.

Benzer Videolar

Insane Grok Grok Bot upgrade! Finally, you can connect Grok Bot to different agent harnesses and run tasks through their native runtimes. Devs just open-sourced HarnessRouter, the infrastructure layer that lets Grok Bot run tasks across: - Codex - Hermes - Claude Code - DeepSeek Harness - System One, powered by Jev - Pi, and 20 more GitHub repo: (don’t forget to star it ⭐) With HarnessRouter, each external specialist gets to use its own harness, model, tools, skills, and agent loop while Grok coordinates the project from one conversation. I tested this by asking Grok Bot to turn a support-ticket CSV into an interactive dashboard. Grok Bot assigned the analysis to DeepSeek Harness with Claude Sonnet 5.5, passed the output to Codex with GPT-5.5, and checked the finished dashboard in its browser. This differs from simply creating more Bots. These workers are not additional Grok Bots, and Grok Bot itself does not switch harnesses. Instead, it remains the coordinator while the delegated tasks run inside separate HarnessRouter sessions with the harness of your choice. So for another task, you can use Claude Code, Hermes, Pi, etc., without requiring a separate integration for task execution, sessions, streaming, and generated files. HarnessRouter standardizes all those operations through the Unified Harness Protocol (UHP). UHP handles sessions, streaming, files, cancellation, and failures through the same interface, regardless of which harness runs the task. I shared the GitHub repo above. And if you want to dive deeper into Grok Bot, I wrote about it in full in a masterclass, including the shared computer, memory, skills, routines, and the macOS setup. Read it below.

Avi Chawla

137,036 görüntüleme • 13 gün önce

Harness Engineering 2.0 is here! We benchmark models all the time but the harness running the model can dramatically improve the result, cost, and execution time too. And finally, devs just open-sourced Harness Arena, where you can test the same task across multiple harness and model combinations side by side. You provide one task and then run it across several model x harness configs that you want to test. Every config receives the same prompt, files, tools, skills, and evaluation checks. Harness Arena then returns: - total cost - execution time - whether the task passed - files and artifacts produced If you want to try it yourself, it is implemented within the open-source HarnessRouter project. Here's the repo: (don't forget to star it ⭐ ) HarnessRouter is a plug-and-play infrastructure layer that lets you run any harness under a single interface, like: - Codex - Hermes - Claude code - DeepSeek Harness - System One, powered by Jev - And 25 more agent harnesses In Harness Arena, the cheapest run does not automatically win. A config must complete the task correctly first. Cost and execution time are compared only among the configurations that pass. Here's the result from one Harness Arena test: - Hermes + GPT-5.2: 5/5 successful runs using 0.47 credits - Claude Code + Opus 4.8: 3/5 successful runs using 223 credits That is around 474x difference in credits, while the more expensive configuration also failed two runs. You can keep the model fixed to measure how much the harness changes the result. Or vary both to find the best harness and model pairing for that task. This helps answer practical questions such as: - Should this task run on Codex or Claude? - Can a cheaper config still pass every check? - Which setup is best to handle this workload? Once you find the best config, you can run future tasks through it using the same Unified Harness Protocol (UHP) interface for sessions, streaming, files, artifacts, cancellation, and failures. So you are no longer choosing an agent stack based only on a model leaderboard. Instead, you can benchmark the complete runtime on the task your product actually needs to solve. To dive deeper, my co-founder wrote an article explaining why model routing is different from harness routing, how UHP works, and what supporting multiple agent runtimes involves. It also covers the local setup, a working request, and how sessions and files move through the system. Read it below.

Avi Chawla

30,046 görüntüleme • 2 gün önce

Another insane Jev use case! Jev is making it dramatically cheaper to evaluate what actually happened inside an agent run. And finally, someone open-sourced a self-improving memory layer that can put that signal to work across agent harnesses: - Claude Code - Codex - Cursor - OpenCode, and 20+ more Beacon by Asymptote Labs continuously captures your agent history across harnesses and uses Jev to identify which runs are actually worth learning from. It then turns the highest-signal workflows, corrections, and debugging patterns into reusable skills. GitHub repo: (don’t forget to star it ⭐ ) Beacon preserves the complete session history. But preserving a run and learning from it are two different things. Most coding-agent sessions contain routine exploration, failed commands, and fixes that only apply to one task. The trace can remain available for inspection without turning every detail into guidance for future agents. Jev scores each run for evidence, reuse potential, and human correction signals. An application policy then decides whether to promote, review, or discard it. The recording shows this in action. Claude receives a coding task, modifies the implementation, and runs the tests. I then provide an edge-case correction, so Claude updates the code and adds regression coverage. Beacon automatically captures the complete session. Jev evaluates whether the correction contains a reusable engineering lesson. Once approved, that lesson becomes available to other coding agents working on the project. Since it works across harnesses: - Claude Code sessions can teach Codex. - Cursor debugging can improve OpenCode. So a problem solved by one agent should not need to be learned from scratch by another. If you want to dive deeper into Jev, I also wrote a hands-on guide to building this Jev-style decision path with open models, entirely locally. Read it below.

Avi Chawla

293,860 görüntüleme • 1 ay önce

Another insane Jev use case! Jev makes it incredibly cheap to evaluate and classify agent runs at scale. And finally, someone open-sourced a self-improving memory layer that can put that capability to work across agent harnesses. It turns your agent sessions into a compounding knowledge layer, where every successful run can make future agents smarter across: - Codex - Claude Code - Cursor - OpenCode and 20+ more Beacon by Asymptote Labs continuously builds a shared history across your agent harnesses and uses Jev to identify the runs worth learning from. It then turns the best workflows, corrections, and debugging patterns into reusable skills. GitHub repo: (don’t forget to star it ⭐) Most agent runs are messy. They contain exploration, failed commands, dead ends, and one-off fixes that should never become permanent memory. So Beacon preserves the full session history, while Jev helps decide what should be promoted, reviewed, or discarded. The recording below shows this in action. Beacon found 579 sessions across 5 coding-agent harnesses and normalized them into one consistent history. From there, Jev surfaces the lessons worth keeping and makes them available across your agent stack. - A pattern learned in Cursor can carry into OpenCode. - A lesson from Claude Code can improve the next Codex run. Every successful run adds to the shared knowledge layer, making future agents smarter. If you want to dive deeper into Jev, I also wrote a breakdown of how it works. The article is quoted below.

Akshay 🚀

121,058 görüntüleme • 1 ay önce

Another insane way to use Jev: Jev makes it dramatically cheaper to identify which corrections and trajectories from an agent run are reusable across agents. And finally, someone open-sourced a self-improving memory layer that can put that signal to work across agent harnesses: - Claude Code - Codex - Cursor - OpenCode - Hermes, and 20+ more Beacon by Asymptote Labs continuously captures agent sessions across harnesses and stores their traces in a shared index. I used it with Jev to build a live cross-agent memory workflow. Beacon captures each run as it happens across all harnesses on my machine. Then Jev evaluates whether the trace contains a reusable engineering lesson, and the approved lesson becomes available to the next agent. GitHub repo: (don't forget to star it ⭐) Preserving an agent run and learning from it are two different problems. Most traces contain file reads, failed commands, routine exploration, and implementation details that only apply to one task. Passing the complete transcript to another agent adds context without identifying what matters. In this workflow, one agent never receives another agent's raw transcript. It receives only the specific engineering lesson produced from the evaluated trace. A correction made in one agent can then prevent the same mistake when another agent encounters a similar problem. The recording shows the complete workflow I built. If you want to dive deeper into Jev, I also wrote a hands-on guide to building this Jev-style decision path with open models, entirely locally. Read it below.

Avi Chawla

70,794 görüntüleme • 16 gün önce