HuggingFace just closed a major gap in harness engineering! (the ultimate guide to multi-harness RL) the same open-weight model can perform well inside one harness, then lose accuracy or produce invalid tool calls when moved to another. this happens because training inside one interface can teach the model its specific tool names, output formats, context structure, and control flow. the model learns how to operate the harness, not just how to solve the task. Hugging Face researchers tested a more portable approach called multi-harness reinforcement learning. instead of training a model through one agent interface, they trained it through Claude Code, Codex, OpenCode, and Mini-SWE-Agent. to make that possible, they connected three open systems. → 𝗢𝗽𝗲𝗻𝗘𝗻𝘃 provides a standard interface between agent harnesses, reinforcement learning environments, and trainers. its capture proxy sits between the harness and model server, recording the exact tokens and generation probabilities needed for training. → 𝗛𝗮𝗿𝗯𝗼𝗿 runs agents against containerized tasks. it keeps the task, harness, and sandbox independent, allowing the same task to be attempted through different harnesses without rebuilding the environment. → 𝗧𝗥𝗟 is Hugging Face’s open-source library for post-training language models. it uses the trajectories captured by 𝗢𝗽𝗲𝗻𝗘𝗻𝘃 to update the model through reinforcement learning. the real breakthrough is where the training data gets captured. each harness keeps its native tools, prompts, context management, retries, and execution loop. the researchers do not recreate those behaviors inside the trainer. 𝗢𝗽𝗲𝗻𝗘𝗻𝘃 observes the model calls passing through each real harness and converts them into usable training sequences. the team trained 𝗟𝗙𝗠𝟮.𝟱-𝟮.𝟲𝗕 across all four harnesses. the share of held-out tasks solved on the first attempt increased from 42.2% to 54.2%, with gains under every harness. the trained model also used 31% fewer tool calls on tasks that both it and the base model solved. training only in OpenCode improved the model too, but most of that gain stayed concentrated in OpenCode. multi-harness training spread the improvement across interfaces. the experiment used one task family, one training seed, and unequal data exposure, so the results are not a universal ranking. even with those limitations, the mechanism matters. open-source models cannot assume one deployment interface. if they need to work across harnesses, that portability must become part of training. Read the full guide here: huggingface.co/spaces/FineEn… if you want to understand harness engineering and what an agent harness actually includes, i wrote a full breakdown to help you get started. the article is quoted below.

Agents without memory aren't agents at all. An LLM can appear to remember because the application keeps sending previous messages back with each request. The model itself is still stateless. Start a new session without stored history, and every preference, decision, and previous outcome disappears. Agent memory solves this at two different scopes: 1️⃣ Short-term memory This is the agent's working state during the current session. It includes recent messages, retrieved documents, uploaded files, tool outputs, and intermediate task state. 2️⃣ Long-term memory This persists across sessions. It stores information the agent may need again, such as user preferences, known facts, previous outcomes, and task instructions. Long-term memory can be divided further: 1) Semantic memory stores facts. For example, a support agent might remember which plan a customer uses or that the customer prefers email over phone calls. 2) Episodic memory stores previous experiences. This could include how an earlier support issue was resolved or what happened during a previous agent run. 3) Procedural memory stores instructions and learned procedures. This includes behavioral rules, tool preferences, and steps the agent should follow when completing a task. These memory types need different write and retrieval policies. A preference should persist until it changes, while an old tool output may only matter during the current session. The model is not learning through weight updates here. The surrounding system adapts by storing, updating, and retrieving state. Oracle AI Agent Memory implements this through short-term threads, summaries, durable memories, automatic extraction, scoped retrieval, and context cards. In Oracle's documented 80-turn evaluation, the system held input near 1,300 tokens per request while flat history grew past 13,900 tokens by the final turn. The managed-memory agent also won 48 evaluated turns, while flat history won 13. The remaining 19 were ties. I worked with the Oracle team on this post to explain how the memory architecture works. The visual above breaks down the memory types the system needs to manage. You can read the full architecture and evaluation here: fandf.co/4AFP7sz Memory is one slot in a much larger harness. The orchestration loop, the tools, the state persistence, and the guardrails all sit around the model too, and memory is the part that decides what the rest of them see on the next turn. I broke down all eleven components of a production agent harness in an article. Read it below.

Jev for RAG, clearly explained! Hybrid search gives you a shortlist. It does not decide which passages contain evidence, which are merely adjacent, or whether the evidence is strong enough to answer. That missing judgment is where Jev fits. Jev sits between retrieval and generation. It does not replace BM25, embeddings, or the LLM. It evaluates the candidates they produce before those candidates enter the context window. → Retrieve wide Combine dense and keyword search, then merge the results with reciprocal rank fusion. This gives Jev a broad candidate pool, such as the top 20 passages shown in the visual. Retrieval still sets the ceiling. If the right passage is missing from this shortlist, Jev cannot recover it. → Judge every candidate together Send the query as Jev’s state. For each candidate, ask a typed yes-or-no question such as “Does C7 help answer this query?” Jev evaluates every question in one packed request and returns a calibrated probability for each passage. This avoids making a separate model call for every query-passage pair. → Let code apply the threshold Your application compares each probability with a threshold. Candidates above it continue to the LLM. Everything below it is removed before generation. Jev makes the fuzzy judgment. Code remains responsible for the actual decision. → Gate the entire answer The same request can check whether the retained passages make the query answerable. It can also flag signs of prompt injection inside a candidate. If answerability falls below the threshold, the application can skip the LLM and return “not in the documents.” The injection score should remain a filtering signal, not a security boundary. The result is a cleaner division of work. Hybrid search retrieves broadly. Jev reranks, filters, and decides whether sufficient evidence exists. The LLM writes only from the passages that survive. Jev’s value here is not simply moving passages up or down a list. It turns relevance into an explicit probability that your application can inspect, threshold, and act on. To summarise: - Retrieval finds the candidates. - Jev decides what deserves context. - The LLM writes the grounded answer. ---- I also built an open-source project showing how to use Jev as a judge for AI observability with Comet Opik. It evaluates support traces for groundedness, request coverage, action honesty, and helpfulness, then records the results as an auditable experiment. You can explore the project here: github.com/patchy631/jev-as-… My article on how Jev works is quoted below.