The Rise of Open-Source Agency: Hermes, OpenHands, and Autonomous AI Systems

Generative AI is evolving beyond a single chat window.
Developers can now run or adapt open‑weight models, and agent frameworks can link these models to files, APIs, browsers, and other tools. By exposing the model to concrete resources, the system can retrieve data, invoke services, and manipulate artifacts directly.
This combination allows the creation of systems capable of executing multi‑step work without requiring human approval at every step. In practice, a model can decide to search a knowledge base, process the results, and commit code changes before a person even sees the intermediate output.

This article explores two concrete examples, the Hermes model family from Nous Research and the OpenHands agent framework, along with the broader ecosystem they represent.

Nous Research Hermes: Instruction‑Tuned for Tool Use

Hermes is a series of open‑weight models fine‑tuned by Nous Research on top of base models such as Llama 3 and Mistral. The fine‑tuning emphasizes instruction following, structured output, and function calling, capabilities that make the model easier to use as the reasoning core of an agent.

Hermes models support a function‑calling format that lets the model emit structured JSON describing which tool to call and with what arguments, rather than producing free‑form text. An orchestration layer can then parse this output and execute the corresponding action:

# Hermes emits structured tool calls that an orchestrator can execute
response = {
    "tool_call": {
        "name": "search_documents",
        "arguments": {"query": "Q3 revenue figures", "limit": 5}
    }
}

# The orchestrator executes the tool and returns the result to the model
result = tools["search_documents"](**response["tool_call"]["arguments"])

Because the model tells the orchestrator exactly which function to invoke, the downstream code can avoid ambiguous parsing and reduce the chance of mis‑execution.

Hermes models are distributed under commercial-friendly licenses (verify specific model cards at https://huggingface.co/NousResearch). Open-weight distribution provides weights and execution code but differs from OSI-approved source licenses. Legal and engineering teams must audit redistribution, fine-tuning, and compute clauses before embedding weights into production topologies.

OpenHands: An Orchestration Layer for Software Engineering

OpenHands (formerly OpenDevin) is an open‑source agent framework focused on software‑engineering tasks. It gives a language model access to a sandboxed environment with a shell, a code editor, a browser, and file‑system access. The model can inspect a repository, edit files, run tests, and prepare a pull request, all within a single session.

from openhands import AgentController, CodeActAgent

agent = CodeActAgent(llm_config={"model": "hermes-3-llama-3.1-70b"})
controller = AgentController(agent=agent, sandbox="docker")

# The agent receives a GitHub issue and works autonomously
result = controller.run(
    task="Fix the failing test in tests/test_auth.py - "
         "the JWT expiry check is using the wrong field name."
)
print(result.summary)

OpenHands operates as an extensible framework for autonomous agent evaluation. Production task resolution correlates directly with repository test coverage, deterministic sandbox containment, and automated verification hooks. Restricting agents to isolated container environments with human-approved diff commits provides reliable guardrails against unverified mutations.

What Can These Systems Do?

When a model and an execution layer are combined, a system can:

• chain searches, calculations, code, and document generation;
• inspect a codebase, propose changes, run tests, and prepare a pull request;
• extract structured records from unstructured documents; and
• coordinate different media or software tools in one workflow.

These are capabilities of a configured system, not guarantees of reliability. Long action chains increase the likelihood that an early mistake will be amplified later. SWE‑bench, a benchmark of real GitHub issues, shows that even the best agent systems resolve roughly 50 % of issues correctly as of 2025, meaningful progress, but far from reliable enough to deploy without review.

How People Use Them

Local‑first experimentation

Developers can run some open‑weight models locally, especially in quantized form via Ollama or llama.cpp. Local execution may reduce data exposure to third parties, but it does not guarantee privacy: logs, plugins, network calls, and the host machine still need protection.

Custom automation

Organizations can connect an agent to internal systems for tasks such as triage, reporting, or document preparation. High‑impact actions, changing orders, sending messages, or approving payments, should require explicit authorization and audit trails.

Research and fine‑tuning

Public weights and auditable orchestrators allow researchers to benchmark tool-calling topologies, error recovery loops, and fine-tuning alignments. Benchmarking demonstrates that structured schema constraining and explicit error feedback loops improve multi-step agent success rates significantly.

Personal assistants

Individuals can build assistants that monitor information sources, summarize changes, or draft responses. Access should be narrowly scoped, and actions should be previewed before they are sent to other people or systems.

Where the Ecosystem May Go

From chat to asynchronous work

Agents may increasingly run for longer periods and return an intermediate result, rather than answering every step synchronously. As duration increases, reliability, cost limits, timeouts, and clear completion criteria become more important.

Agent‑aware operating systems

Operating systems and enterprise platforms may expose permissioned interfaces for agents. The useful idea is not unrestricted access, but explicit capabilities: an agent should receive only the files, applications, and actions required for its task. A capability‑based model lets administrators grant a code‑review agent read‑only access to a repository while denying it network privileges.

Specialized teams of agents

A coordinator can delegate research, coding, review, or communication to specialized components. While multi‑agent designs can improve the separation of concerns, they also add coordination overhead and more places for errors to occur.

Reflecting on the Current State

Open‑weight models like Hermes and agent frameworks like OpenHands separate language reasoning from execution. This modularity supports experimentation and local control, but it does not remove the need for security, testing, and human accountability. The key question is not just what an agent can do, but what it is allowed to do and how its actions can be checked.