DAILY NEWS

Stay Ahead, Stay Informed – Every Day

Advertisement
TECH & AI
Your AI’s tests pass. That doesn’t mean the code works.
jackminion 0



You ask a coding agent to fix a bug. It writes the code, writes the tests, CI goes green, you merge. The bug’s still there.

The agent’s job was to turn the check green. The honest way to do that is to fix the code. The lazy way is to write a test that passes no matter what the code does. CI can’t tell those two apart. A green check means the tests passed, not that the code is right.

It’s easy to miss in review, because the test sits right there looking like proof:

test(“parses the config”, () => {
const result = parseConfig(rawInput);
expect(result).toBeDefined();
});

Enter fullscreen mode

Exit fullscreen mode

That passes whether parseConfig works perfectly or returns nothing useful on every input. It checks nothing. Adding more tests like it just raises your coverage number, not your odds of catching a bad change.

So I built ClaimCheck (https://github.com/moonrunnerkc/claimcheck). Instead of trusting the agent’s tests, it tries to break them. If a test still passes after the supposedly fixed code is broken on purpose, the test was never really checking the fix, and it gets blocked. Same answer every time, no AI making the call. So far it’s caught every cheat in a set of twelve hand-built cases. Twelve is small, and there’s no public release yet, so treat that as a direction, not a finished result.

Some cheats slip through anyway. If the agent writes a real, solid test that locks in the wrong answer, every check passes. The only way to know the answer’s wrong is to already know the right one, and nothing in the pull request can tell you that except the agent you’re trying to catch. The one thing that helps is a clue from outside it, like a human-written bug report you can run the fix against.

There’s a second, wider tool, Swarm Orchestrator (https://github.com/moonrunnerkc/swarm-orchestrator). It flags suspicious changes and keeps a tamper-evident record for audits. The record-keeping is the solid part. The catching is not: on real pull requests its accuracy is still low, and that’s the half I’m hardening now.

The next step is comparing the old code’s behavior to the new directly. The catch is that a wrong change and a harmless cleanup can look the same from the outside, and a tool that blocks good code is worse than one that lets a bad change through. That’s the part I’m still working out.



Source link

TECH & AI
Vendor Chunking: The React Optimization I Wish I’d Known Earlier
jackminion 0



I ignored my bundle size for months. By the time I checked, my production build was several megabytes of JavaScript in a single file — and every deploy forced my users to download all of it again. Vendor chunking is what I wish I’d known earlier.

Let’s say you are building a project using React, and for that project you need some component library, a library to handle date-related things, or a library to handle your state. So you reach for the usual suspects — Material UI, dayjs, TanStack Query, Redux and so on.

Initially, everything will work smoothly for you as well as for your end users. But as you keep shipping new features and adding dependencies, the bundle quietly grows. Locally, you don’t notice. But in production, it’s the end users who end up paying the price. What happens behind the scenes is that, when dependencies are included in the initial bundle, they can significantly increase the JavaScript downloaded by the browser. As a result, you end up with a poor Lighthouse score, slow initial load times, and a large JavaScript bundle — all of which hurt the user experience.

Your production build looks like this:

dist/assets/index-xxxx.js → 1.2 MB

Enter fullscreen mode

Exit fullscreen mode

This is exactly the kind of problem vendor chunking is designed to solve.

What is Vendor Chunking?

Vendor chunking is a technique where you can separate the third-party dependencies from your main bundle chunk. So you will have a main chunk which will contain your main application code and a vendor chunk which will contain the third-party dependency code.

How does Vendor Chunking help with large bundle size?

When you implement vendor chunking, your application is typically split into at least two separate bundles:

Main Chunk: Contains your application code
Vendor Chunk: Contains third-party dependencies and libraries

When a user visits your website for the first time, the browser downloads both chunks and stores them in the cache. This is where caching becomes very useful.

It’s worth noting that vendor chunking doesn’t come into play on the user’s first visit, because the browser still has to fetch both the chunks. The real performance gains show up when a user revisits the website and the cached vendor chunk can be reused.

Since third-party dependencies do not change frequently, the vendor chunk usually remains the same across deployments. On the other hand, whenever you ship new features, bug fixes, or other updates, your application code changes — which results in a new main chunk being generated.

When you generate a new production build, the bundler will again create:

A new main chunk containing the updated application code
The same vendor chunk, because the dependency code has not changed

Now consider this scenario where a user’s browser has already cached both the chunks because the user has already visited your website, and you deploy a new feature to the production. As a result, the user’s browser only needs to download the new main chunk, while the cached vendor chunk can be reused. This is how vendor chunks help in improving user experience.

Vendor Chunking in Action

Now let’s understand this whole thing using the code. I have a React project where I have installed multiple dependencies such as MUI, Chart.js, Lodash, dayjs and React Router.

Before Vendor Chunking, the build will look something like this:

Note: I’ve disabled tree-shaking for this demo to keep the bundle size large and make the impact of vendor chunking more visible.

The build will contain only one JS file and the browser has to download this large ~4.6 MB file.

Now I will implement vendor chunking by adding this code block in my vite.config.ts file:

Note: I’m using Vite v8, which uses Rolldown as the bundler. If you’re on an older Vite version with Rollup, the config syntax will be different

So after this, the build will look something like this:

As you can see, now we have two JS files:

Now the browser has to download both of these files so that our application loads correctly. Here comes the crazy part. Let’s update the code and try to generate the new production build. Here’s what it will generate:

If you compare the files with the previous build, you will find that only index-xx.js changed, while vendor-xx.js stays the same, because we didn’t upgrade any package versions; we only updated the application code.Now when a user revisits our website, the browser will only fetch the new index-xx.js from the server, vendor-xx.js will be served from cache.

This is how vendor chunking helps in performance improvement for web applications.

Splitting Vendors Further

So far we have bundled all the dependencies into a single chunk. This works well for small to medium applications, but as the dependency list grows, a single vendor chunk has a drawback. If you update the version of any library, a new vendor chunk will be generated and users have to re-download the whole thing – even if 95% of the code is same.

To tackle this issue, we can split vendors into multiple chunks. For example, you can keep your UI library in one chunk, your utility libraries in another, and your charting library in a third:

The final node_modules group is a catch-all so dependencies like React land in a vendor chunk too, rather than your main bundle.

After this config, your build output will look something like this:

Note: Just don’t go overboard with splitting — too many small chunks can hurt performance due to HTTP overhead and less effective compression

Wrapping Up

Vendor chunking is one of those optimizations that costs you a few lines of config and pays you back on every deploy. The core idea is simple: your application code changes often, third-party code doesn’t — so why force your users to re-download libraries they already have?

If you haven’t audited your production bundle in a while, run a build and take a look. You might be surprised how much of it is third-party code waiting to be cached properly.



Source link

TECH & AI
The Open-Source Agent War of 2026: Hermes Agent vs AutoGPT vs OpenAI Agents vs CrewAI
jackminion 0



Hermes Agent Challenge Submission: Write About Hermes Agent

This is a submission for the Hermes Agent Challenge: Write About Hermes Agent

The Open-Source Agent War of 2026: Hermes Agent vs AutoGPT vs OpenAI Agents vs CrewAI

The AI Agent Ecosystem Is Getting Crowded Fast

In the last two years, “AI agents” went from experimental repos to full ecosystems.

Now we have:

AutoGPT spawning autonomous loops
CrewAI orchestrating multi-agent teams
OpenAI Agents offering structured tool execution
Hermes Agent pushing persistent memory and system-level architecture

And suddenly, developers are asking a very real question:

Which agent framework should I actually use in production?

Because the reality is:

They are not interchangeable
They are not solving the same problem
And they are not built with the same philosophy

In this post, I break down the landscape in a practical, engineering-focused way.

No hype.

No marketing.

Just architecture, tradeoffs, and real-world fit.

The Four Major Players

Let’s define the contenders clearly.

1. Hermes Agent

Hermes Agent is designed as a persistent, memory-driven agent system.

Core ideas:

long-term memory as a first-class layer
skill-based execution model
multi-agent orchestration
workflow-driven automation
system-like architecture

It behaves less like a chatbot framework and more like an AI operating system layer.

2. AutoGPT

AutoGPT is one of the earliest autonomous agent experiments.

Core ideas:

goal-driven loops
self-prompting behavior
tool usage through iteration
minimal structure, high autonomy

It is best described as:

A recursive agent loop with tool access.

3. CrewAI

CrewAI focuses on structured multi-agent collaboration.

Core ideas:

role-based agents
task delegation
sequential and parallel workflows
human-defined orchestration

It is designed for:

“AI teams working together.”

4. OpenAI Agents

OpenAI Agents focus on production-grade tool execution and orchestration.

Core ideas:

structured tool calling
safety and reliability layers
API-first agent design
enterprise readiness

It is less experimental and more controlled.

Design Philosophy Comparison

Framework
Philosophy

Hermes Agent
AI as a persistent system

AutoGPT
Fully autonomous loop

CrewAI
Collaborative agent teams

OpenAI Agents
Controlled production agents

This philosophical difference explains almost everything else.

Core Feature Comparison

Feature
Hermes Agent
AutoGPT
CrewAI
OpenAI Agents

Open Source
Yes
Yes
Yes
Partial

Self-hosting
Yes
Yes
Yes
Limited

Persistent Memory
Strong
Weak
Medium
Limited

Multi-agent support
Native
Experimental
Core feature
Structured

Tool integration
Modular
Basic
Good
Excellent

Learning capability
Strong (memory-driven)
Low
Medium
Medium

Ease of setup
Medium
Medium
Easy
Easy

Production readiness
Medium
Low–Medium
Medium
High

Community support
Growing
Large
Growing
Large

Extensibility
High
Medium
High
Medium

Developer Experience Comparison

Hermes Agent

Requires architectural thinking
Powerful but opinionated
Best for long-running systems
Feels like building infrastructure

AutoGPT

Easy to experiment with
Hard to control in production
Often unpredictable
Great for prototypes

CrewAI

Very developer-friendly
Clear role definitions
Easy mental model
Good balance of structure and flexibility

OpenAI Agents

Smooth API experience
Strong documentation
Production-focused
Less flexible at system level

Architecture Comparison

Hermes Agent Architecture

flowchart TD

User –> HermesCore

HermesCore –> MemoryLayer
HermesCore –> SkillSystem
HermesCore –> WorkflowEngine
HermesCore –> SubAgents
HermesCore –> ToolLayer

SubAgents –> SharedMemory
SkillSystem –> MemoryLayer
WorkflowEngine –> SubAgents

Enter fullscreen mode

Exit fullscreen mode

Key idea:

Everything revolves around persistent memory + system execution.

AutoGPT Architecture

flowchart TD

Goal –> AgentLoop
AgentLoop –> LLM
LLM –> ToolUse
ToolUse –> Observation
Observation –> AgentLoop

Enter fullscreen mode

Exit fullscreen mode

Key idea:

Infinite loop driven by self-prompting.

CrewAI Architecture

flowchart TD

Task –> ManagerAgent

ManagerAgent –> Worker1
ManagerAgent –> Worker2
ManagerAgent –> Worker3

Worker1 –> Output
Worker2 –> Output
Worker3 –> Output

Enter fullscreen mode

Exit fullscreen mode

Key idea:

Role-based collaboration.

OpenAI Agents Architecture

flowchart TD

UserRequest –> Orchestrator
Orchestrator –> ToolCalls
ToolCalls –> ExecutionLayer
ExecutionLayer –> Response

Enter fullscreen mode

Exit fullscreen mode

Key idea:

Structured tool execution pipeline.

Real-World Use Case Comparison

Scenario 1: Solo Developer

Best choice: CrewAI or Hermes Agent

CrewAI: easier setup, fast results
Hermes: better for long-term project memory

AutoGPT is too unstable for consistent use.

OpenAI Agents may feel too rigid.

Scenario 2: Startup Team

Best choice: Hermes Agent or OpenAI Agents

Hermes: evolving product knowledge + memory
OpenAI Agents: stable production workflows

CrewAI works well for internal coordination.

AutoGPT is not ideal.

Scenario 3: Enterprise

Best choice: OpenAI Agents

Why:

governance
reliability
safety controls
structured execution

Hermes Agent is promising but still maturing here.

Scenario 4: Research Lab

Best choice: Hermes Agent

Because:

persistent memory across experiments
evolving hypotheses tracking
multi-agent research pipelines

CrewAI also works well, but lacks deep memory layer.

Scenario 5: Personal Productivity

Best choice: CrewAI or AutoGPT

CrewAI: structured assistants
AutoGPT: experimental automation

Hermes Agent is powerful but heavier than needed for simple tasks.

Strengths and Weaknesses Breakdown

Hermes Agent

Strengths

Persistent memory
System-level architecture
Multi-agent coordination
Long-term reasoning support

Weaknesses

Complexity
Higher setup cost
Still evolving ecosystem

AutoGPT

Strengths

Simplicity of concept
Fully autonomous loops
Easy experimentation

Weaknesses

Unpredictable behavior
Weak production control
No real memory system

CrewAI

Strengths

Clean multi-agent model
Easy developer experience
Good structure for teams

Weaknesses

Limited long-term memory
Less system-level depth

OpenAI Agents

Strengths

Production-grade stability
Strong tool ecosystem
Excellent documentation

Weaknesses

Less open system design
Limited architectural flexibility
Dependency on platform constraints

When Hermes Agent Is the Wrong Choice

Hermes Agent is NOT ideal when:

you need quick one-off automation
you want zero-setup solutions
you are building simple chatbot flows
you require strict enterprise compliance out of the box
you don’t need long-term memory or state

In short:

If your problem is stateless, Hermes is overkill.

Decision Tree: Which Agent Framework Should You Choose?

Do you need persistent memory across time?
├── Yes → Hermes Agent
└── No → continue

Do you need production-grade tool reliability?
├── Yes → OpenAI Agents
└── No → continue

Do you need multi-agent teamwork structure?
├── Yes → CrewAI
└── No → continue

Do you want experimental autonomous behavior?
├── Yes → AutoGPT
└── No → CrewAI or OpenAI Agents

Enter fullscreen mode

Exit fullscreen mode

Final Thoughts: Where This Is All Heading

We are still in the early phase of agent frameworks.

Right now, each system is optimizing a different axis:

AutoGPT → autonomy
CrewAI → collaboration
OpenAI Agents → reliability
Hermes Agent → persistence + system thinking

But over the next 2–3 years, these boundaries will blur.

We will likely see:

memory becoming standard
multi-agent systems becoming default
workflows becoming composable
agents becoming long-running systems, not sessions

And eventually:

Agent frameworks will stop being “tools for prompts”and become “operating layers for digital workforces.”

In that future, Hermes Agent’s direction — persistent, system-oriented intelligence — may become less of a niche idea and more of a baseline expectation.

The real competition won’t be between frameworks.

It will be between architectures.

And that shift is already starting.



Source link