标签：#Agents

Hermes Agent: Why Open-Source AI Agents Are Changing How We Build Software Introduction Artificial intelligence has moved far beyond simple chatbots. Today, developers are building systems that can reason through problems, use tools, execute tasks, and make decisions across multiple steps. These systems are commonly known as AI agents. Recently, I explored Hermes Agent, an open-source agentic framework designed to run on your own infrastructure while providing advanced capabilities such as planning, tool usage, and multi-step reasoning. After spending time understanding how it works, I came away with a greater appreciation for the role open-source agents may play in the future of software development. In this article, I'll explain what Hermes Agent is, what makes it interesting, and why developers should pay attention to the growing ecosystem of open-source AI agents. What Is Hermes Agent? Hermes Agent is an open-source agent framework designed to perform tasks that require more than a single response from a language model. Instead of simply answering questions, Hermes Agent can: Break down complex objectives into smaller steps Use external tools when necessary Maintain context across multiple actions Perform reasoning before taking action Execute workflows autonomously This approach allows developers to build systems capable of handling real-world tasks that would normally require human intervention. For example, rather than asking an AI to summarize a document, you could instruct an agent to: Find relevant documents. Analyze their contents. Extract key insights. Generate a report. Save the results to a specified location. The agent coordinates each step as part of a larger workflow. Why Open Source Matters One of the most compelling aspects of Hermes Agent is that it is open source. Many powerful AI tools today operate behind closed platforms where developers have limited visibility into how systems work. Open-source alternatives provide several advantages: Transp

Overview We built the Ota skill because too much "AI repo automation" is still fake confidence. An agent clones a repo, finds a plausible command, edits the right file, and looks smart right up until it does something expensive and stupid. It runs the wrong test path. It installs tools globally because local setup was unclear. It patches around a missing service as if the repo were healthy. That failure is usually blamed on the model. Most of the time it is a repo problem. The repository never made its real operating path explicit enough for the agent to follow without guessing. Ota already gives the repo a machine-readable contract through ota.yaml . The skill exists to teach agents how to behave around that contract: what to trust, what to run, and when to stop instead of improvising. It is not a replacement for ota.yaml . It is not an MCP server. It is not a hidden automation layer. It is the missing operating guide for agents working in Ota repos. Why an Ota skill exists We kept seeing the same pattern: the agent was fast, but the repo was vague. Without a repo-specific operating guide, an agent may see several possible paths: run the command from the README copy the command from CI infer setup from package.json , pyproject.toml , or go.mod run a broad test command because it looks conventional install tools globally because a local command failed patch around a missing service instead of identifying the readiness gap Some of those choices work. Some are dangerous. Some look fine locally and still miss the only verification path that matters. Our view is simple: if a repo has ota.yaml , that file should beat README prose, shell folklore, and whatever command happens to look familiar. Declared tasks, writable paths, setup requirements, and validation commands should be treated as contract facts. The skill exists to make that behavior explicit across agents that support skills. What the skill teaches an agent The official skill lives in ota-run/skills . It is aime

The people deciding that AI can replace your job are also the ones least likely to understand what your job truly involves, according to Box founder Aaron Levie, who pointed to this as an example of “AI psychosis.” Indeed, ClickUp recently cut 22% of its workforce for AI agents, tech layoffs in 2026 are already nearly matching all of 2025, […]

Cognition makes Devin, the first and arguably most successful AI coding agent. But famed coder Wu says it isn't designed to supplant human programmers.

If you are an open-source maintainer, developer advocate, or builder, you know the cycle: you build an amazing tool, but writing the launch blog post, documentation, or tutorial takes hours. For the Hermes Agent Challenge , I wanted to build something that solves this exact problem. I built devto-blogger , a custom, prompt-driven skill for the brand new Hermes Agent by Nous Research. It autonomously scans any workspace or codebase, analyzes the architecture, and drafts a fully-structured, rich Markdown technical article ready for publication on DEV. 🚀 What is Hermes Agent? Hermes Agent is an open-source agentic system built by Nous Research (the lab behind the famous Hermes LLM models). Unlike basic coding copilots or simple chatbot wrappers, Hermes is: Environment-Aware : It runs sandboxed in Docker, Modal, Daytona, SSH, or locally. Connected : It interfaces with Telegram, Discord, Slack, WhatsApp, and more. Closed Learning Loop : It has persistent memory and creates custom skills on the fly from its own experience. 🔧 The Entry: The devto-blogger Skill In Hermes Agent, a "skill" is defined by a simple, declarative Markdown file ( SKILL.md ) located in the ~/.hermes/skills/ directory. By utilizing a prompt-driven skill structure, we can guide the agent's behavior globally without writing complex Python orchestration scripts. Here is the custom skill I designed and installed for this challenge: --- name : devto-blogger description : " Scan the codebase and generate a comprehensive Dev.to technical blog post draft." version : 1.0.0 author : Hermes Agent Developer license : MIT platforms : [ linux , macos , windows ] metadata : hermes : tags : [ devto , blogging , documentation , markdown , technical-writing ] related_skills : [ plan , design-md ] --- # Dev.to Technical Blogger Skill Use this skill when you need to write an in-depth technical post, review, or tutorial about the active workspace or codebase. ## Core Behavior 1. **Codebase Inspection** : Scan repository

Let Your AI Agent Manage skill itself Most developer tools still assume the human is the operator. You read the documentation. You install the CLI. You decide where files should go. You copy commands from a README, paste them into a terminal, check the output, fix the path, and then explain the final state back to your AI coding agent. That made sense when tools were only built for humans. But AI coding agents now run commands, inspect files, follow project conventions, and repair broken local state. If a tool is meant to help agents, the better question is not: How does a human use this CLI? It is: Can the agent operate the CLI by itself? That is one of the quiet but important ideas behind aweskill : it is a CLI-first Skill package manager that AI agents can operate themselves. Website: aweskill.webioinfo.top It is already used as supporting infrastructure for several Webioinfo projects: awescholar — AI-agent-operable scientific literature discovery and curation. Search, annotate, filter, and report on academic papers. aweshelf — Session bookmark manager for Claude Code and Codex. Bookmark, categorize, and restore sessions with aweswitch profiles. Awesome AI Meets Biology — A curated survey of AI applications in biology, bioinformatics, and biomedical research, powered by awescholar. The Old Workflow: You Manage the Agent's Tools When a new AI Agent needs a Skill, the usual workflow looks like this: You find the Skill. You download or copy it. You locate the agent's Skill directory. You place SKILL.md in the right folder. You restart the agent. You hope the next agent uses the same layout. This is manageable once. It becomes messy when you use Codex, Claude Code, Cursor, Gemini CLI, Windsurf, Qwen Code, OpenCode, or any other coding agent side by side. Each one has its own directory layout and conventions. The human becomes the package manager. That is backward. If the agent is already capable of editing your repo, running tests, and diagnosing failures, it should

ShareBox is my self-hosted streaming server: a PHP thing I built because I just wanted to send someone a link to a movie without installing Plex and its ten gigabytes of dependencies. It runs on my seedbox, serves my users, and one morning I notice it's starting to pick up a few stars on GitHub. And then, that little voice: "does this thing actually hold up?" Because between "works on my machine" and "code that strangers are going to install on their own box," there's a chasm. A chasm full of flaws I can't see anymore, because I've had my nose in it for weeks. Normally, you re-read your code. Except re-reading 22,000 lines alone, honestly, you do it badly: you skim over what you think you already know. So I tried something else — unleashing a pack of 26 AI agents on it, each with a precise mission, and seeing what surfaced. Spoiler: they found a flaw that had been sitting right under my eyes from the start. 26 agents to comb through my own code The idea wasn't "AI, tell me if my code is good" — that always produces the same encouraging, useless mush. The idea was to orchestrate : split the audit into roles, run the agents in parallel, then have a final, deliberately harsh agent tear apart the conclusions. The pipeline looked like this: eleven readers start in parallel, each swallowing an entire slice of the code (the core, the streaming handlers, the API, the front end, the tests, the Docker setup…). Their reports flow up into an architecture synthesis and a test-coverage analysis. Then twelve "radar" agents each score one single axis — security, performance, architecture, tests… And finally, a "verdict" agent re-reads every score in adversarial mode: its job is to knock down the ones that are too kind. Audit pipeline: 11 readers in parallel, then synthesis, then 12 radar agents, then an adversarial verdict. 11 readers in parallel each slice of the code read in full Architecture + coverage synthesis connect the pieces, measure the gaps 12 radar agents one agent = on

One unified API for Gemini, OpenAI, Anthropic, HuggingFace, Ollama, on-device Gemma, and GGUF models — with tool calling, memory, and safety guardrails built in. The Problem Building AI agents in Flutter is fragmented. Every provider has a different API shape. There's no standard way to switch between cloud and on-device inference. Tool calling, persistent memory, and safety guardrails are always custom implementations. The result: developers rebuild the same plumbing for every project. What It Is genesis_ai_sdk is a universal Flutter SDK for building AI agents that run locally and in the cloud. One clean API. Seven providers. Zero vendor lock-in. Supports: Gemini (Google) OpenAI (GPT-4o) Anthropic (Claude) HuggingFace (any public model, no download needed) Ollama (local server, no API key) On-device Gemma (fully offline) On-device GGUF via llama.cpp (fully offline) Switch providers by changing one line. Your agent code stays the same. Quick Start — 10 Lines of Code import 'package:genesis_ai_sdk/genesis_ai_sdk.dart' ; final agent = GenesisAgent ( provider: GeminiProvider ( apiKey: 'YOUR_KEY' ), systemPrompt: 'You are a helpful assistant.' , tools: [ GenesisTools . calculator , GenesisTools . dateTime ], ); final response = await agent . chat ( 'What is 1337 * 42, and what day is it?' ); print ( response ); The agent figures out which tool to call, executes it, and returns the answer. No prompt engineering needed. The Features That Actually Matter Real Tool Calling — Not Just Text The ReAct loop is fully implemented. The agent reasons → calls tools → observes results → repeats until it has a complete answer. An onStep callback fires for every intermediate step — perfect for building a "thinking…" UI. Custom tools are five lines: final weatherTool = GenesisTool . define ( name: 'get_weather' , description: 'Returns weather for a city.' , params: { 'city' : ToolParam . string ( description: 'City name' )}, execute: ( args ) async = > fetchWeather ( args [ 'city' ]), )

Hey there! If you've been keeping up with the AI space lately, you know we're in the middle of something genuinely historic. What used to be science fiction is becoming production code — and it's happening fast. The Big Shift: Agents Over Assistants For years, we've been building chatbots. Helpful little assistants that answer questions. But something changed in 2026, and honestly, it happened so quietly that most people missed it. Agents aren't chatbots. A chatbot waits for you to ask. An agent sees an objective and acts on it. Autonomously. That's the difference. And the market just woke up to it. What's Actually Happening Right Now DBS Bank + Visa's Agentic Commerce Tests In February, these giants quietly completed trials of AI-driven agents executing credit card transactions automatically. No human in the loop. No confirmation needed. Just agents doing their job. If you're thinking "That sounds risky" — yeah. But it worked. BridgeWise's AI Wealth Agent A US fintech company just unveiled an AI agent that personalizes investment portfolios at scale . Something that would take a team of human financial advisors years to do, this agent does in minutes. Microsoft's Supply Chain Agents They're operating over 100 AI agents in their own supply chain. And they're planning to equip every employee with AI support by end of 2026. The Emergence of "Freelance Agentics" This one's wild. Solopreneurs are using AI agents to do the work of 10-person teams. Legal, accounting, architecture — fields that were supposedly "too complex" for automation are getting flipped upside down by a single person + a good agent framework. Why This Matters for Developers Here's what I think is important: This isn't hype. These are real companies running real agents in production. If you're a developer in 2026 and you don't understand how to build with agents, you're going to feel left behind. Not because everyone's obsessed with them — but because they're genuinely useful . The frameworks are solid

The most downloaded and widely used methodology in the Claude Code ecosystem is Superpowers , with over 208k stars⭐️ and 18.5k forks🍴 on GitHub (and counting!) Going from raw Claude Code to using Superpowers is as revolutionary as going from a manual transmission to an automatic. Here's why this analogy holds: Planning Mode vs. Coding Mode When we build with Claude (or Codex, or Gemini...), we're usually in one of two states: planning mode coding mode Like shifting gears in a car🚘, moving between these modes effectively is what makes it all work. Skip the shift, and you're just revving your engine (aka burning context and going nowhere.) Superpowers lets Claude automatically detect and shift between these modes. It picks up on ambiguity in your prompt and ensures it fully understands the task before entering coding mode. No manual shifting required! Slower, but for Good Reason Superpowers can feel slower and less satisfying than raw Claude Code, like how driving an automatic can feel less engaging than a manual. But both serve the same critical purpose: they stop you from blowing up your engine! That said, there's still a time and place for raw Claude. Sometimes you want direct, fast, unmediated output. But that minor gain in speed often isn't worth the added complexity, the ambiguity risk, and the tradeoffs that come with it. The Layer Underneath Entire is building the foundation beneath all of this — capturing every session and decision, and linking it to the commit it produced. It's the full record of how the code was written, not just the code itself. So the question is this: how will you put your agent in drive🚘?

I Built a Local AI Agent That Thinks Like a Brain, Not a Database Most AI agents today are sophisticated autocomplete engines. Ask them something, they answer. Ask again in a new conversation, they start from zero. The context window is the only memory they have. Serenity is different. It's a fully local AI agent that encodes experiences the way biological brains do — semantically clustered, causally structured, and self-organizing. No cloud. No API calls to a vector database. No data leaves your machine. Ever. The Core Problem with Current AI Memory The standard approach to AI memory is essentially a hack: you stuff embeddings into a vector DB, do nearest-neighbor retrieval, and dump the results into the prompt. It sort of works. But it's not how brains work. Your brain doesn't search for memories. When one fires, related ones light up automatically. Serenity's architecture — called S.E.R.A (Semantic Experience Reasoning Agent) — tries to bridge that gap. Here's the key difference: Traditional Approach Serenity Vector search on embeddings Semantic node activation Prompt-injected context Persistent working memory One-shot retrieval Emergent recall via association Static embeddings Pruned & crystallized over time How It Works: The Neural Node Network At the core is the Neural Node Network (NNN) . Instead of storing facts in isolation, Serenity encodes experiences in causal format: ACTION → BEFORE → OUTCOME → AFTER When she learns something, she doesn't file it in a folder. She finds where it semantically belongs in a web of related concepts. Similar things cluster together — the same way neurons that fire together wire together. Then the abstraction layer kicks in. Three or more related concepts crystallize into a higher-order node: the thing they all have in common that none of them says directly. Those nodes bundle into pathways. Those pathways grow into domains. She also has inhibitors and pruning — weak connections get cut so strong ones sharpen. Her knowledge ge

Every token your agent spends on file I/O is wasted reasoning capacity. I was building a document processing agent — the kind that reads incoming research reports, extracts key findings, and produces executive briefings. Nothing exotic. The kind of workflow thousands of teams are automating right now. The PDF I was testing with was 2MB. Dense text. A typical industry research report. When I measured the token cost of processing it inline, the number was 97,354 input tokens — just to get the text into Claude's context. At claude-sonnet-4-6 pricing, that's $0.29 per document. For a pipeline that processes 500 reports a month, you're looking at $150/month before your agent writes a single word of output. That's the problem nobody talks about in the AI agent space. Everyone optimises prompt engineering and output tokens. The silent cost is input: the files, the content, the raw data you're shoving into context before the agent can do anything useful. How the token count explodes When you pass a document to an agent inline, one of two things happens: Option A — Base64 encoding. You read the binary file, encode it, embed it in the prompt. A 2MB PDF in base64 is ~2.7MB of text. At roughly 3.5 characters per token, that's ~770,000 tokens before your agent has read a single word. This is catastrophic. Don't do this. Option B — Text extraction. You extract the raw text content first (via pdftotext , PyMuPDF, or equivalent), then pass the text to the agent. Better — but a 2MB PDF with dense content still yields ~97,000 tokens of extracted text. You've paid for every word, every header, every footnote. Either way, the document content dominates your context window, crowds out your system prompt, and you're burning money on file I/O instead of reasoning. The alternative: specialist services via MCP Model Context Protocol (MCP) is Anthropic's open standard for connecting AI agents to external tools and services. The key insight is simple: your agent doesn't need to contain the co

This is a submission for the Hermes Agent Challenge : Write About Hermes Agent I Didn't Start With Hermes Six months ago I started building a set of agent skills and personas for how I build software. Not generic prompts — opinionated role files. A /backend-architect that owns schema and recommendation logic. A /test-engineer that writes Vitest coverage and flags weak acceptance criteria. A /project-manager that maintains planning docs and closes iterations cleanly. These roles have evolved across multiple projects. They have layering rules, discovery checklists, inheritance from a base engineering discipline file. They produce consistent, reviewable work because they're scoped — the backend architect doesn't touch test files, the test engineer doesn't redesign the schema, each persona has a defined mandate and exits cleanly. When I heard about Hermes Agent, my first instinct wasn't "let me learn a new system." It was: can I run my existing system inside this? The answer is yes. That's what this article is about — what it looks like to bring a mature workflow into Hermes, what you gain, where it breaks down, and what I'd do differently. What Hermes Is (and Isn't) to Someone Who Already Has a Workflow Hermes is an LLM-agnostic orchestration layer. It has its own skill system, its own soul.md concept for persistent agent identity, built-in cron scheduling and MCP management. All of that is real and useful. But it's also a runtime. If you have skills that work, you can bring them in. I installed a local Hermes instance — few clicks, straightforward setup — and ran it inside VSCode's integrated terminal pointed at my existing persona files. No migration. No rewrite. My /backend-architect runs in Hermes the same way it runs in Claude Code. Before settling on this, I'd tried a couple of other paths — a VPS instance with a Telegram interface for ideation, and attempting to build through a browser-based terminal. The VPS was fine for sketching ideas. The browser terminal ma

This is a submission for the Hermes Agent Challenge : Build With Hermes Agent What I Built Real brewing knowledge lives in human experience — in roaster guides, in community notes, in what a barista learned from last Tuesday's pour. It doesn't accumulate anywhere. Every brew is forgotten. Ask any AI and you get statistical averages: 93°C, 1:16 ratio, four minutes. Technically defensible. Practically generic. Worse still for rare origins where training data is thin. Demo For coffee drinkers Visit brew-guide-production.up.railway.app . No account. No setup. No AI client required. Pick your coffee origin, roast level, and brew method. What comes back isn't a generic recipe — it's community consensus: the grind, temperature, ratio, and brew time that real people have logged and rated for that origin, plus step-by-step technique guidance (bloom timing, pour stages, agitation style). If data is sparse for your origin, the confidence tier says so honestly and falls back to method defaults rather than making something up. This is for the person who just picked up a bag of Kenyan peaberry and wants to know how to do it justice. It works for anyone who cares about their cup — no technical knowledge required. For developers and AI clients Connect to any MCP-capable client in one line: https://brew-guide-production.up.railway.app/mcp Ask your AI: "recommend a pour over for Ethiopian light roast." What comes back is a traceable community consensus object: brew parameters, a confidence tier (high/medium/low), the source brews that contributed, and method-specific technique guidance. You can see where the knowledge came from and how certain the system is — a fundamentally different epistemic object from an AI-generated recipe. Code GitHub: yuens1002/brew-guide Five MCP tools — get_brewing_methods , recommend , log_brew , search_brews , compare_brew — over Streamable HTTP transport. Public, no auth required. My Tech Stack Layer Technology HTTP Hono 4 + @hono/node-server MCP @modelc

As AI agents move from experiments to production, AWS, Cloudflare, and others are redesigning cloud infrastructure for a future dominated by machine-generated internet traffic instead of human users.

When a team hits a ceiling with their coding agent, the first instinct is to reach for a better model. The reasoning feels obvious: the model is the part that produces the code, the code is the part that is wrong, therefore a smarter model will produce more correct code. Wait for the next release. Switch providers. Bump the tier. This is sometimes right. It is much more often wrong, and the cost of being wrong about it is that you spend months waiting for a model upgrade to solve a problem the model was never the cause of. The harness is the cause of the problem more often than the model. Most teams discover this only after they have exhausted the model-upgrade reflex and finally turn to look at everything else. What a model upgrade actually buys you Newer, stronger models do tangibly improve some things. They handle longer contexts more reliably. They make fewer simple reasoning errors on complex tasks. They follow nuanced instructions more closely. On a fixed prompt, with a fixed task, a better model produces a better answer. What model upgrades do not change: The fact that the agent has no idea your team prefers functional components over class components, because the convention is not in any file the agent reads. The fact that your tests do not actually fail when the code is wrong, so the agent can ship broken code that passes CI. The fact that your codebase has three different ways of handling errors and the agent picks one at random on each PR. The fact that the rule the senior engineer keeps repeating in reviews is not encoded anywhere the next session can see. None of these are fixed by a smarter model. They are fixed by a better harness. A smarter model loaded into the same broken harness will produce slightly more sophisticated versions of the same problems. The diagnostic The diagnostic is one question: when the agent fails, does it fail because it lacked information, or because it lacked capability? A capability failure looks like: the task required reas

Undisclosed addition in jqwik instructed AI coding agents to delete app output.

The same agent, same prompts, did markedly different work on two codebases I work in. One has a test suite that runs in eight seconds. The other takes twelve minutes. The eight-second project gets a careful, iterative collaborator. The twelve-minute project gets a confident guesser. I noticed it first as a vibe. The agent in the slow codebase would write five files at once, then announce the task complete without having run anything end to end. The agent in the fast codebase would write one function, run the tests, react to the failure, fix it, run them again. Same model. Same configuration. The only difference was how expensive it was to learn whether the previous step was right. That is the whole post in one sentence. An agent's effective intelligence is bounded by how fast it can verify its hypotheses. Cut the verification cost and you raise the agent's apparent IQ. Raise it and you lower the agent's apparent IQ. The model in the middle is unchanged. Why this binds harder for agents than for humans A human engineer can hold a hypothesis in their head. "I think this works. I will check it later." The cost of holding the hypothesis is roughly free; the human has institutional memory, intuition, a sense of what the code does that does not require running the code to confirm. They can defer verification without losing fidelity. An agent cannot. It has no intuition about your codebase. The only ground truth it has access to is what the tests say, what the type checker says, what the build says. When those signals are cheap, the agent uses them constantly. When they are expensive, the agent stops using them and starts speculating. Speculation by an agent looks plausible. It produces code that compiles, follows the patterns it has seen in your repository, names things sensibly. The problem is that plausible is not the same as correct. The agent that speculates is shipping a guess; the agent that iterates is shipping a tested answer. From the diff alone, they can be hard

By Umair Sheikh, founder of Gateplex Autonomous AI agents are shipping fast. LangChain, CrewAI, AutoGen — the frameworks are mature, the tutorials are everywhere, and developers are connecting agents to real systems: databases, payment APIs, email, file storage. And then something goes wrong. Not because the code is buggy. Because the agent did exactly what it was told — and what it was told turned out to be a problem nobody anticipated. I spent nearly a decade in fintech and responsible AI policy watching this pattern repeat. A system behaves perfectly in testing. In production, an edge case triggers behaviour that was technically correct but operationally catastrophic. By the time anyone notices, the action has already executed. The problem is not the agent. The problem is that there is nothing between the agent's decision and the real world. The gap nobody talks about Most agent observability tools log what happened. That is useful for debugging. It does nothing to prevent the next incident. What agents actually need is a governance layer — something that intercepts every action before it executes, checks it against your rules, and either allows it, flags it for review, or blocks it outright. This is what a firewall does for network traffic. Your AI agent deserves the same treatment. What this looks like in practice Here is a simple LangChain agent calling an external tool: from langchain.agents import initialize_agent , Tool from langchain.llms import OpenAI def send_payment ( amount : str ) -> str : # This actually moves money return f " Payment of { amount } sent " tools = [ Tool ( name = " SendPayment " , func = send_payment , description = " Send a payment " )] agent = initialize_agent ( tools , OpenAI (), agent = " zero-shot-react-description " ) agent . run ( " Send $5000 to vendor account " ) This works. It also has no guardrails whatsoever. If the agent misreads the input, hallucinates a vendor, or gets manipulated via prompt injection, the payment goes

Sesame’s new iOS app brings its conversational AI agents to the public, offering more natural back-and-forth interactions designed to feel less like traditional chatbots and more like talking to a person.