Joel Reeside

Founder of Cinemadic Agency | Posts related to AI Video Production - Advertising - Entrepreneurship - Health and Weightlifting

[Akshay 🚀 @akshay_pachaar]

Sam Altman made the case for open-source harnesses in July.

a month later, someone shipped it, and it's more efficient than most managed harnesses.

here is the problem it was aimed at:

a large share of your agent's token bill is the model rereading things it already read.

that isn't the model's doing. the runtime around it decides what goes into every prompt and how often the model gets called.

for example, an agent queries a CRM at step four and gets back 400 rows. those rows get piled up in the conversation history.

by step nineteen, the model has to read those rows fifteen times unnecessarily, and every token read is billed at input rates.

it happened because your harness assembled that prompt on every turn and kept the rows in it.

that gives you two levers: how much context the harness carries forward, and how often it calls the model.

there are four practical ways to keep the prompt from growing unnecessarily:

→ load tool schemas on demand. a server with 100 tools doesn't need to put all 100 into every prompt when the agent only calls two.

→ offload large results to disk. turn a large response into a short preview and a file path instead of replaying the entire result on every turn.

→ delegate to subagents. let a subagent spend thirty tool calls in its own context and return one summary to the root agent.

→ run toolchains in code. one script calls three tools, joins the results, and returns a table instead of three turns each dragging a full response.

but reducing context is only half the job. you also need to control how often the model gets called.

a good harness should avoid unnecessary planning, verification, and reflection when the work can be completed in fewer steps.

@TrueFoundry's open-source agent harness, TrueForge, is built around both of those controls.

it sits between the model and the tools, deciding what goes into every prompt and when another model call is actually needed. it also breaks token usage down across the harness, skills, instructions, tools, and messages.

DevRev's Enterprise-Bench is where this gets tested, on multi-step tasks of the kind where an agent pulls records from one system and reconciles them against another.

TrueFoundry ran TrueForge there against Claude Managed Agents, both on the same model, and both finished the same number of tasks.

the tie is the part that matters, because it means the gap underneath is not a quality tradeoff.

TrueForge reached that score on close to a third of the tokens, with roughly 40% fewer trips back to the model. for the same result, that comes out around 2.7x cheaper than Claude Managed Agents.

swapping in an open model made it sharper still. TrueForge with GLM-5.2 scored a little higher than either setup above, and the entire benchmark run cost about $3 at list prices.

being open source matters beyond the license here. the model underneath can be swapped without rewriting the agent, and the whole thing can run inside your own environment when the data cannot leave it.

all of this comes down to the runtime around the model, the context it carries, the tools it exposes, and how many times it goes back to the model.

that is what a production harness actually owns.

the full task list, the per-run numbers, and the MIT-licensed code are on GitHub: https://t.co/Ueo1InZH7M

(don't forget to star 🌟)

you can read more about the same in the article quoted below.

thanks to the TrueForge team for working with me on this one.

[JO. Z @jojodecayz]

ComfyUI can now split a flat image into separate editable layers and hand you a PSD that opens straight in Photoshop. Thanks to Node 2.0.

The new layer nodes come from Terry (@jtydhr88) on our frontend team. A compositor editor is right in the graph, so you can arrange everything before you ever leave ComfyUI.

How it works:
- Run the Seedream 5.0 layer separation template in Comfy Cloud
- Add multiple images into the layers
- Arrange and composite them in the editor
- Export every layer to a PSD and keep editing in Photoshop

Built on nodes 2.0.

[Bryce DeGroat @NFL_Convo]

Drafting guys with an easy schedule is a CHEAT CODE in Fantasy Football…

Here’s the Top 10 players with the easiest schedule at their position this year🏈⬇️

[el.cine @EHuanglu]

this AI upscaler on comfyui is absolutely crazy

[Vox @Voxyz_ai]

Competition has Hermes moving fast lol.

These past few days, I moved part of my work into Grok Bot to test it. Bot-to-Bot handoffs and group chat are already built into the product. Handoffs are smooth, and group chat just works.

Now Hermes Desktop has shipped Bot Mode too. Every existing profile now appears as a persistent Bot with its own role, model, memory and Skills. Bots can communicate with each other, while users still control the model and configuration for each one.

The next round of multi-agent competition comes down to the collaboration experience: who can get roles, memory, handoffs and group chat working smoothly first. Open source clearly isn’t giving up this layer.

[Nic Cruz Patane @niccruzpatane]

Man, Elon wasn’t messing around. Wartime CEO was definitely engaged. Since then:

• xAI fully absorbed into SpaceX
• $60B Acquisition of Cursor AI
• Grok 4.6, 4.7 coming in a few weeks
• 1.4 GW nameplate capacity online at Colossus cluster (Over 2 GW by end of 2026)
• Tesla FSD V14 (V15 operating in Robotaxis)
• SpaceX engineering data now training the next Grok models
• Macrohard / Digital Optimus
• Grok Bot
• Terafab construction underway
• SpaceX AI Satellites

[Machina @EXM7777]

this is basically everything you need to know about building a GTM agent with Hermes...

[Nicolas Camara @nickscamara_]

we just made research index 100% free

we also added 41M+ life science papers. your agent can search them all. no API cost

available now

[DeepSeek @deepseek_ai]

🧩 DeepSeek Harness v0.1 is now available in Developer Preview!

🔹 We’re opening it up to developers building agent harnesses worldwide and open-sourcing the codebase in MIT license.
🔹 Powered by the Cordis meta-framework, DeepSeek Harness is an agent harness built around one core idea: Everything is a plugin. Models, tools, skills, sessions, sandboxes, filesystems, loops, orchestration, and UI are ALL implemented as plugins, and can be mixed, matched, replaced, and extended.

Try it now!
https://t.co/2YWSvJHhKA

[David Ondrej @DavidOndrej1]

every Agentic Engineer should use this repo

it's not even a debate

https://t.co/yL6WI1bcww

[nevian @neviannn]

This paper is f*cking genius

A computer science paper from Stanford AI Systems Lab formalizes why multi-agent pipelines fail and introduces the Control Plane Pattern for autonomous research

The result: cuts investigation latency from 4 weeks down to 30 minutes while reducing token usage by ~10x with zero context handoff decay

The crazy part is how naive multi-agent chains degrade context at every handoff - causing Synthesis agents to recommend field visits for a payer tier problem

Deterministic signal queues, single centralized reasoning agents, and Knowledge Graph control planes replace brittle handoff pipelines

Most AI teams build multi-agent pipelines where specialized agents pass context down a broken chain

This paper structures agentic analytics into a bounded, graph-constrained operating system

Read the complete paper + article below

Bookmark it for future reference

[Tony Simons @tonysimons_]

Most people use AI like a smarter search box.

That’s the shallow end.

I mapped 20 Hermes Agent workflows that turn the model into an operator across research, monitoring, content, coding, shopping, memory, and more.

Steal one:

https://t.co/jsSrW7q9HZ

[tonbi @tonbistudio]

Today's video takes a deeper dive into the Hermes Desktop plugins! I show you exactly how you can position plugins, the forms they can take, and the limitations

Watch me actually make the plugins in this repo (and play a little Zelda at the end)

[tonbi @tonbistudio]

https://t.co/UBT2pnOxaW

[CyrilXBT @cyrilXBT]

SOMEONE JUST BUILT A WAY TO TURN ANY TECHNICAL BOOK INTO A CLAUDE SKILL

You give it a 500-page book once.

It doesn't dump the entire thing into Claude's context.

Instead, it extracts:
- frameworks
- decision rules
- anti-patterns
- glossary
- cheatsheet
- every chapter
…into a structured skill.

Then Claude loads only the chapter it actually needs.

Ask `/your-book replication`
Claude finds the right chapter and answers from the actual source instead of guessing.

The crazy part: The project reports 24×–51× fewer tokens than dumping the entire book into context.

You pay the discovery cost once.
After that, the book becomes part of your agent's workflow.

And it isn't limited to books.

Feed it your internal docs, research papers, API specs, runbooks, or an entire documentation folder.

You stop asking Claude to remember a 300-page document.
You turn the document into something Claude can actually use.

One command:

`npx skills add virgiliojr94/book-to-skill`

This is what happens when you stop treating knowledge as context and start treating it as infrastructure.

The book-to-skill repository.

[Jensen Huang @JensenHuang]

Lightning strikes for continuous and long-run agents!

Nemotron 3.5 Lightning is smart, fast, efficient and open.

[Argona @Argona0x]

whoever leaked this has bigger balls than sense

someone gave a fleet of Claude agents shared memory so they would stop contradicting each other, then measured both the bill and the output: the version that talked most made 2.4x the api calls of the version that won, and hallucinated 34% more than doing nothing at all, 0.658 against 0.492

i ran the same question past two of my own agents afterwards and got two different answers about which file owns the config. each one was individually right and the pair was wrong, which is the whole failure in one line

this is Graph Engineering, the layer that decides which agents may talk to each other at all, and it installs into the agent you already pay for:

- decide which agents may share state at all, because every edge you draw is a channel a mistake can travel down
- measure divergence per PAIR instead of as a fleet average, across what they believe about place, time and task history
- gate on that number and stop the pair above your threshold before it reasons, rather than repairing the output afterwards
- let compressed summaries replace whole states: the verified protocol landed 0.463 against 0.658 for full broadcast
- cut the sync frequency until it hurts, since the winning setup used 58% fewer calls than the one that broke it
- never propagate a state nobody checked, because the contamination effect came in at d=1.18, a full standard deviation of extra lying
- keep the shared layer small enough to diff, which is what a written standard does and a running conversation cannot
- re-run the check after every model upgrade, because this was 8 scenarios on one model family at n=30 per condition
- and learn where it does not bite: on plain software tasks every condition converged under 0.2 and the whole effect vanished

turns out the ranking is the uncomfortable part: verified summaries 0.463, no synchronisation at all 0.492, full broadcast 0.658. the middle option is doing nothing, and it beat the thing everyone builds first

the group agreeing is what it looks like when every agent copied the same mistake, which is why a fleet that hallucinates has a replication problem and keeps getting handed a smarter model instead

so the question for your own setup: if you asked two of your agents the same thing right now, would they answer the same way

bookmark this one. the layer underneath it, deciding which arrows between agents exist at all, is built step by step in the piece below ↓

[CopilotKit🪁 @CopilotKit]

🎉 Introducing Hermes in ANY app

Your personal agent automating work, controlling software, or running tasks with generative UI, human-in-the-loop and more.

Use Hermes anywhere over AG-UI:

→ React & React Native
→ Next.js
→ Angular
→ Slack, MS Teams

Check it out ↓
@NousResearch @imbabybrooklyn @Teknium @austinkpickett

[Shann³ @shannholmberg]

one of the best write-ups I have seen on getting hermes agent to build your life OS and second brain

EP released a single prompt that creates 4 connected layers:

1. a markdown knowledge base that is your source of truth
2. a persistent memory pointer so every future session knows where it lives
3. agent skills for capturing, retrieving, and correcting context
4. a private life tracker for habits, goals, projects, and reviews, synced across sessions

it is a lot to parse, so I visualized the whole system, save this and send it with the prompt to your agent

[Akshay 🚀 @akshay_pachaar]

a fully open-source self-improving harness.

Prime Intellect just shipped Prime Agent, which turns a frontier model into a Recursive Language Model.

context becomes a variable the model programs over, and sub-agents become ordinary function calls.

let's understand what all of this means:

almost every agent you use today works inside fixed harness. someone wrote the system prompt, picked the tool schemas, decided when history gets compacted, and shipped it.

the model spends part of every session working around that scaffolding instead of working on the task. when the same failure repeats three times in a long run, you are the one who fixes it, after the run is over.

Prime Agent removes that ceiling with two pieces.

the first is the RLM design. a persistent IPython kernel is the model's only tool, so long inputs never have to enter the prompt at all. the model greps, partitions, and spawns child calls over the data instead of reading all of it back in.

the second is the Continual Harness. four kinds of state sit outside the conversation and stay writable:

→ Prompt: supplemental instructions the agent appends when it learns something the base prompt never told it.

→ Memory: findings from earlier turns that would otherwise die with the context window.

→ Skills: recurring workflows packaged as importable Python, so the next run imports the procedure instead of rediscovering it.

→ Sub-agents: specs for the children it spawns, tuned once and reused across parallel, background, and long-lived runs.

the /refine command reads the current trajectory, applies the smallest edit it can justify, and records what triggered it. the base system prompt stays immutable, and any update can be rolled back by ID.

with Opus 5 driving it, Prime Agent reports 95.5% on ARC-AGI-3, just past the reported human expert baseline of 95.4%. when that benchmark launched, frontier models were scoring under one percent. nobody trained a new model to close that gap.

worth noting that in Factorio runs the same loop found and then optimized scoring exploits, which is roughly what you would expect once an agent can edit its own instructions.

with Opus 5 driving it, Prime Agent reports 95.5% on ARC-AGI-3, just past the reported human expert baseline of 95.4%. when that benchmark launched, frontier models were scoring under one percent. nobody trained a new model to close that gap.

the scaffold stopped being something you configure once and became something the run improves as it goes.

Prime agent is MIT licensed, single command install, works with open and closed models.

check it out on GitHub: https://t.co/h4QSrJNJQE

since we are talking about RLMs, i wrote a detailed article on how Recursive Language Models work.

the article is quoted below.