Navigate back to the previous page in browser history. Requires browser_navigate to be called first.

Click on an element identified by its ref ID from the snapshot (e.g., '@e5'). The ref IDs are shown in square brackets in the snapshot output. Requires browser_navigate and browser_snapshot to be called first.

The element reference from the snapshot (e.g., '@e5', '@e12')

Close the browser session and release resources. Call this when done with browser tasks to free up Browserbase session quota.

Get browser console output and JavaScript errors from the current page. Returns console.log/warn/error/info messages and uncaught JS exceptions. Use this to detect silent JavaScript errors, failed API calls, and application warnings. Requires browser_navigate to be called first.

If true, clear the message buffers after reading

Get a list of all images on the current page with their URLs and alt text. Useful for finding images to analyze with the vision tool. Requires browser_navigate to be called first.

Navigate to a URL in the browser. Initializes the session and loads the page. Must be called before other browser tools. For simple information retrieval, prefer web_search or web_extract (faster, cheaper). Use browser tools when you need to interact with a page (click, fill forms, dynamic content).

The URL to navigate to (e.g., 'https://example.com')

Press a keyboard key. Useful for submitting forms (Enter), navigating (Tab), or keyboard shortcuts. Requires browser_navigate to be called first.

Key to press (e.g., 'Enter', 'Tab', 'Escape', 'ArrowDown')

Scroll the page in a direction. Use this to reveal more content that may be below or above the current viewport. Requires browser_navigate to be called first.

Direction to scroll

Get a text-based snapshot of the current page's accessibility tree. Returns interactive elements with ref IDs (like @e1, @e2) for browser_click and browser_type. full=false (default): compact view with interactive elements. full=true: complete page content. Snapshots over 8000 chars are truncated or LLM-summarized. Requires browser_navigate first.

If true, returns complete page content. If false (default), returns compact view with interactive elements only.

Type text into an input field identified by its ref ID. Clears the field first, then types the new text. Requires browser_navigate and browser_snapshot to be called first.

The element reference from the snapshot (e.g., '@e3')

The text to type into the field

Take a screenshot of the current page and analyze it with vision AI. Use this when you need to visually understand what's on the page - especially useful for CAPTCHAs, visual verification challenges, complex layouts, or when the text snapshot doesn't capture important visual information. Returns both the AI analysis and a screenshot_path that you can share with the user by including MEDIA:<screenshot_path> in your response. Requires browser_navigate to be called first.

What you want to know about the page visually. Be specific about what you're looking for.

If true, overlay numbered [N] labels on interactive elements. Each [N] maps to ref @eN for subsequent browser commands. Useful for QA and spatial reasoning about page layout.

clarify

Ask the user a question when you need clarification, feedback, or a decision before proceeding. Supports two modes:

1. **Multiple choice** — provide up to 4 choices. The user picks one or types their own answer via a 5th 'Other' option.
2. **Open-ended** — omit choices entirely. The user types a free-form response.

Use this tool when:
- The task is ambiguous and you need the user to choose an approach
- You want post-task feedback ('How did that work out?')
- You want to offer to save a skill or update memory
- A decision has meaningful trade-offs the user should weigh in on

Do NOT use this tool for simple yes/no confirmation of dangerous commands (the terminal tool handles that). Prefer making a reasonable default choice yourself when the decision is low-stakes.

The question to present to the user.

Choices:
Up to 4 answer choices. Omit this parameter entirely to ask an open-ended question. When provided, the UI automatically appends an 'Other (type your answer)' option.

cronjob

Manage scheduled cron jobs with a single compressed tool.

Use action='create' to schedule a new job from a prompt or one or more skills.
Use action='list' to inspect jobs.
Use action='update', 'pause', 'resume', 'remove', or 'run' to manage an existing job.

Jobs run in a fresh session with no current-chat context, so prompts must be self-contained.
If skill or skills are provided on create, the future cron run loads those skills in order, then follows the prompt as the task instruction.
On update, passing skills=[] clears attached skills.

NOTE: The agent's final response is auto-delivered to the target. Put the primary
user-facing content in the final response. Cron jobs run autonomously with no user
present — they cannot ask questions or request clarification.

Important safety rule: cron-run sessions should not recursively schedule more cron jobs.

One of: create, list, update, pause, resume, remove, run

Required for update/pause/resume/remove/run

For create: the full self-contained prompt. If skill or skills are also provided, this becomes the task instruction paired with those skills.

For create/update: '30m', 'every 2h', '0 9 * * *', or ISO timestamp

Optional human-friendly name

Optional repeat count. Omit for defaults (once for one-shot, forever for recurring).

Delivery target: origin, local, telegram, discord, slack, whatsapp, signal, matrix, mattermost, homeassistant, dingtalk, feishu, wecom, email, sms, or platform:chat_id or platform:chat_id:thread_id for Telegram topics. Examples: 'origin', 'local', 'telegram', 'telegram:-1001234567890:17585', 'discord:#engineering'

Optional per-job model override used when the cron job runs

Optional per-job provider override used when resolving runtime credentials

Optional per-job base URL override paired with provider/model routing

For list: include paused/completed jobs

Optional single skill name to load before executing the cron prompt

Optional ordered list of skills to load before executing the cron prompt. On update, pass an empty array to clear attached skills.

Optional pause reason

Spawn one or more subagents to work on tasks in isolated contexts. Each subagent gets its own conversation, terminal session, and toolset. Only the final summary is returned -- intermediate tool results never enter your context window.

TWO MODES (one of 'goal' or 'tasks' is required):
1. Single task: provide 'goal' (+ optional context, toolsets)
2. Batch (parallel): provide 'tasks' array with up to 3 items. All run concurrently and results are returned together.

WHEN TO USE delegate_task:
- Reasoning-heavy subtasks (debugging, code review, research synthesis)
- Tasks that would flood your context with intermediate data
- Parallel independent workstreams (research A and B simultaneously)

WHEN NOT TO USE (use these instead):
- Mechanical multi-step work with no reasoning needed -> use execute_code
- Single tool call -> just call the tool directly
- Tasks needing user interaction -> subagents cannot use clarify

IMPORTANT:
- Subagents have NO memory of your conversation. Pass all relevant info (file paths, error messages, constraints) via the 'context' field.
- Subagents CANNOT call: delegate_task, clarify, memory, send_message, execute_code.
- Each subagent gets its own terminal session (separate working directory and state).
- Results are always returned as an array, one entry per task.

What the subagent should accomplish. Be specific and self-contained -- the subagent knows nothing about your conversation history.

Background information the subagent needs: file paths, error messages, project structure, constraints. The more specific you are, the better the subagent performs.

Toolsets to enable for this subagent. Default: inherits your enabled toolsets. Common patterns: ['terminal', 'file'] for code work, ['web'] for research, ['terminal', 'file', 'web'] for full-stack tasks.

Task goal

Task-specific context

Toolsets for this specific task

Batch mode: up to 3 tasks to run in parallel. Each gets its own subagent with isolated context and terminal session. When provided, top-level goal/context/toolsets are ignored.

Max tool-calling turns per subagent (default: 50). Only set lower for simple tasks.

Run a Python script that can call Hermes tools programmatically. Use this when you need 3+ tool calls with processing logic between them, need to filter/reduce large tool outputs before they enter your context, need conditional branching (if X then Y else Z), or need to loop (fetch N pages, process N files, retry on failure).

Use normal tool calls instead when: single tool call with no processing, you need to see the full result and apply complex reasoning, or the task requires interactive user input.

Available via `from hermes_tools import ...`:

  web_search(query: str, limit: int = 5) -> dict
    Returns {"data": {"web": [{"url", "title", "description"}, ...]}}
  web_extract(urls: list[str]) -> dict
    Returns {"results": [{"url", "title", "content", "error"}, ...]} where content is markdown
  read_file(path: str, offset: int = 1, limit: int = 500) -> dict
    Lines are 1-indexed. Returns {"content": "...", "total_lines": N}
  write_file(path: str, content: str) -> dict
    Always overwrites the entire file.
  search_files(pattern: str, target="content", path=".", file_glob=None, limit=50) -> dict
    target: "content" (search inside files) or "files" (find files by name). Returns {"matches": [...]}
  patch(path: str, old_string: str, new_string: str, replace_all: bool = False) -> dict
    Replaces old_string with new_string in the file.
  terminal(command: str, timeout=None, workdir=None) -> dict
    Foreground only (no background/pty). Returns {"output": "...", "exit_code": N}

Limits: 5-minute timeout, 50KB stdout cap, max 50 tool calls per script. terminal() is foreground-only (no background or pty). If the session uses a cloud sandbox backend, treat it as resumable task state rather than a durable always-on machine.

Print your final result to stdout. Use Python stdlib (json, re, math, csv, datetime, collections, etc.) for processing between tool calls.

Also available (no import needed — built into hermes_tools):
  json_parse(text: str) — json.loads with strict=False; use for terminal() output with control chars
  shell_quote(s: str) — shlex.quote(); use when interpolating dynamic strings into shell commands
  retry(fn, max_attempts=3, delay=2) — retry with exponential backoff for transient failures

Python code to execute. Import tools with `from hermes_tools import web_search, terminal, ...` and print your final result to stdout.

memory

Save durable information to persistent memory that survives across sessions. Memory is injected into future turns, so keep it compact and focused on facts that will still matter later.

WHEN TO SAVE (do this proactively, don't wait to be asked):
- User corrects you or says 'remember this' / 'don't do that again'
- User shares a preference, habit, or personal detail (name, role, timezone, coding style)
- You discover something about the environment (OS, installed tools, project structure)
- You learn a convention, API quirk, or workflow specific to this user's setup
- You identify a stable fact that will be useful again in future sessions

PRIORITY: User preferences and corrections > environment facts > procedural knowledge. The most valuable memory prevents the user from having to repeat themselves.

Do NOT save task progress, session outcomes, completed-work logs, or temporary TODO state to memory; use session_search to recall those from past transcripts.
If you've discovered a new way to do something, solved a problem that could be necessary later, save it as a skill with the skill tool.

TWO TARGETS:
- 'user': who the user is -- name, role, preferences, communication style, pet peeves
- 'memory': your notes -- environment facts, project conventions, tool quirks, lessons learned

ACTIONS: add (new entry), replace (update existing -- old_text identifies it), remove (delete -- old_text identifies it).

SKIP: trivial/obvious info, things easily re-discovered, raw data dumps, and temporary task state.

The action to perform.

Which memory store: 'memory' for personal notes, 'user' for user profile.

The entry content. Required for 'add' and 'replace'.

Short unique substring identifying the entry to replace or remove.

Route a hard problem through multiple frontier LLMs collaboratively. Makes 5 API calls (4 reference models + 1 aggregator) with maximum reasoning effort — use sparingly for genuinely difficult problems. Best for: complex math, advanced algorithms, multi-step analytical reasoning, problems benefiting from diverse perspectives.

The complex query or problem to solve using multiple AI models. Should be a challenging problem that benefits from diverse perspectives and collaborative reasoning.

patch

Targeted find-and-replace edits in files. Use this instead of sed/awk in terminal. Uses fuzzy matching (9 strategies) so minor whitespace/indentation differences won't break it. Returns a unified diff. Auto-runs syntax checks after editing.

Replace mode (default): find a unique string and replace it.
Patch mode: apply V4A multi-file patches for bulk changes.

Edit mode: 'replace' for targeted find-and-replace, 'patch' for V4A multi-file patches

File path to edit (required for 'replace' mode)

Text to find in the file (required for 'replace' mode). Must be unique in the file unless replace_all=true. Include enough surrounding context to ensure uniqueness.

Replacement text (required for 'replace' mode). Can be empty string to delete the matched text.

Replace all occurrences instead of requiring a unique match (default: false)

V4A format patch content (required for 'patch' mode). Format:
*** Begin Patch
*** Update File: path/to/file
@@ context hint @@
 context line
-removed line
+added line
*** End Patch

process

Manage background processes started with terminal(background=true). Actions: 'list' (show all), 'poll' (check status + new output), 'log' (full output with pagination), 'wait' (block until done or timeout), 'kill' (terminate), 'write' (send raw stdin data without newline), 'submit' (send data + Enter, for answering prompts).

Action to perform on background processes

Process session ID (from terminal background output). Required for all actions except 'list'.

Text to send to process stdin (for 'write' and 'submit' actions)

Max seconds to block for 'wait' action. Returns partial output on timeout.

Line offset for 'log' action (default: last 200 lines)

Max lines to return for 'log' action

Read a text file with line numbers and pagination. Use this instead of cat/head/tail in terminal. Output format: 'LINE_NUM|CONTENT'. Suggests similar filenames if not found. Use offset and limit for large files. Reads exceeding ~100K characters are rejected; use offset and limit to read specific sections of large files. NOTE: Cannot read images or binary files — use vision_analyze for images.

Path to the file to read (absolute, relative, or ~/path)

Line number to start reading from (1-indexed, default: 1)

Maximum number of lines to read (default: 500, max: 2000)

Search file contents or find files by name. Use this instead of grep/rg/find/ls in terminal. Ripgrep-backed, faster than shell equivalents.

Content search (target='content'): Regex search inside files. Output modes: full matches with line numbers, file paths only, or match counts.

File search (target='files'): Find files by glob pattern (e.g., '*.py', '*config*'). Also use this instead of ls — results sorted by modification time.

Regex pattern for content search, or glob pattern (e.g., '*.py') for file search

'content' searches inside file contents, 'files' searches for files by name

Directory or file to search in (default: current working directory)

Filter files by pattern in grep mode (e.g., '*.py' to only search Python files)

Maximum number of results to return (default: 50)

Skip first N results for pagination (default: 0)

Output format for grep mode: 'content' shows matching lines with line numbers, 'files_only' lists file paths, 'count' shows match counts per file

Number of context lines before and after each match (grep mode only)

Search your long-term memory of past conversations, or browse recent sessions. This is your recall -- every past session is searchable, and this tool summarizes what happened.

TWO MODES:
1. Recent sessions (no query): Call with no arguments to see what was worked on recently. Returns titles, previews, and timestamps. Zero LLM cost, instant. Start here when the user asks what were we working on or what did we do recently.
2. Keyword search (with query): Search for specific topics across all past sessions. Returns LLM-generated summaries of matching sessions.

USE THIS PROACTIVELY when:
- The user says 'we did this before', 'remember when', 'last time', 'as I mentioned'
- The user asks about a topic you worked on before but don't have in current context
- The user references a project, person, or concept that seems familiar but isn't in memory
- You want to check if you've solved a similar problem before
- The user asks 'what did we do about X?' or 'how did we fix Y?'

Don't hesitate to search when it is actually cross-session -- it's fast and cheap. Better to search and confirm than to guess or ask the user to repeat themselves.

Search syntax: keywords joined with OR for broad recall (elevenlabs OR baseten OR funding), phrases for exact match ("docker networking"), boolean (python NOT java), prefix (deploy*). IMPORTANT: Use OR between keywords for best results — FTS5 defaults to AND which misses sessions that only mention some terms. If a broad OR query returns nothing, try individual keyword searches in parallel. Returns summaries of the top matching sessions.

Search query — keywords, phrases, or boolean expressions to find in past sessions. Omit this parameter entirely to browse recent sessions instead (returns titles, previews, timestamps with no LLM cost).

Optional: only search messages from specific roles (comma-separated). E.g. 'user,assistant' to skip tool outputs.

Max sessions to summarize (default: 3, max: 5).

Manage skills (create, update, delete). Skills are your procedural memory — reusable approaches for recurring task types. New skills go to ~/.hermes/skills/; existing skills can be modified wherever they live.

Actions: create (full SKILL.md + optional category), patch (old_string/new_string — preferred for fixes), edit (full SKILL.md rewrite — major overhauls only), delete, write_file, remove_file.

Create when: complex task succeeded (5+ calls), errors overcome, user-corrected approach worked, non-trivial workflow discovered, or user asks you to remember a procedure.
Update when: instructions stale/wrong, OS-specific failures, missing steps or pitfalls found during use. If you used a skill and hit issues not covered by it, patch it immediately.

After difficult/iterative tasks, offer to save as a skill. Skip for simple one-offs. Confirm with user before creating/deleting.

Good skills: trigger conditions, numbered steps with exact commands, pitfalls section, verification steps. Use skill_view() to see format examples.

create patch edit delete write_file remove_file

The action to perform.

Skill name (lowercase, hyphens/underscores, max 64 chars). Must match an existing skill for patch/edit/delete/write_file/remove_file.

Full SKILL.md content (YAML frontmatter + markdown body). Required for 'create' and 'edit'. For 'edit', read the skill first with skill_view() and provide the complete updated text.

Text to find in the file (required for 'patch'). Must be unique unless replace_all=true. Include enough surrounding context to ensure uniqueness.

Replacement text (required for 'patch'). Can be empty string to delete the matched text.

For 'patch': replace all occurrences instead of requiring a unique match (default: false).

Optional category/domain for organizing the skill (e.g., 'devops', 'data-science', 'mlops'). Creates a subdirectory grouping. Only used with 'create'.

Path to a supporting file within the skill directory. For 'write_file'/'remove_file': required, must be under references/, templates/, scripts/, or assets/. For 'patch': optional, defaults to SKILL.md if omitted.

Content for the file. Required for 'write_file'.

Skills allow for loading information about specific tasks and workflows, as well as scripts and templates. Load a skill's full content or access its linked files (references, templates, scripts). First call returns SKILL.md content plus a 'linked_files' dict showing available references/templates/scripts. To access those, call again with file_path parameter.

The skill name (use skills_list to see available skills)

OPTIONAL: Path to a linked file within the skill (e.g., 'references/api.md', 'templates/config.yaml', 'scripts/validate.py'). Omit to get the main SKILL.md content.

List available skills (name + description). Use skill_view(name) to load full content.

Optional category filter to narrow results

terminal

Execute shell commands on a Linux environment. Filesystem usually persists between calls.

Do NOT use cat/head/tail to read files — use read_file instead.
Do NOT use grep/rg/find to search — use search_files instead.
Do NOT use ls to list directories — use search_files(target='files') instead.
Do NOT use sed/awk to edit files — use patch instead.
Do NOT use echo/cat heredoc to create files — use write_file instead.
Reserve terminal for: builds, installs, git, processes, scripts, network, package managers, and anything that needs a shell.

Foreground (default): Commands return INSTANTLY when done, even if the timeout is high. Set timeout=300 for long builds/scripts — you'll still get the result in seconds if it's fast. Prefer foreground for everything that finishes.
Background: ONLY for long-running servers, watchers, or processes that never exit. Set background=true to get a session_id, then use process(action="wait") to block until done — it returns instantly on completion, same as foreground. Use process(action="poll") only when you need a progress check without blocking.
Do NOT use background for scripts, builds, or installs — foreground with a generous timeout is always better (fewer tool calls, instant results).
Working directory: Use 'workdir' for per-command cwd.
PTY mode: Set pty=true for interactive CLI tools (Codex, Claude Code, Python REPL).

Do NOT use vim/nano/interactive tools without pty=true — they hang without a pseudo-terminal. Pipe git output to cat if it might page.
Important: cloud sandboxes may be cleaned up, idled out, or recreated between turns. Persistent filesystem means files can resume later; it does NOT guarantee a continuously running machine or surviving background processes. Use terminal sandboxes for task work, not durable hosting.

The command to execute on the VM

ONLY for servers/watchers that never exit. For scripts, builds, installs — use foreground with timeout instead (it returns instantly when done).

Max seconds to wait (default: 180). Returns INSTANTLY when command finishes — set high for long tasks, you won't wait unnecessarily.

Working directory for this command (absolute path). Defaults to the session working directory.

Seconds between automatic status checks for background processes (gateway/messaging only, minimum 30). When set, I'll proactively report progress.

Run in pseudo-terminal (PTY) mode for interactive CLI tools like Codex, Claude Code, or Python REPL. Only works with local and SSH backends. Default: false.

Convert text to speech audio. Returns a MEDIA: path that the platform delivers as a voice message. On Telegram it plays as a voice bubble, on Discord/WhatsApp as an audio attachment. In CLI mode, saves to ~/voice-memos/. Voice and provider are user-configured, not model-selected.

The text to convert to speech. Keep under 4000 characters.

Optional custom file path to save the audio. Defaults to ~/.hermes/audio_cache/<timestamp>.mp3

todo

Manage your task list for the current session. Use for complex tasks with 3+ steps or when the user provides multiple tasks. Call with no parameters to read the current list.

Writing:
- Provide 'todos' array to create/update items
- merge=false (default): replace the entire list with a fresh plan
- merge=true: update existing items by id, add any new ones

Each item: {id: string, content: string, status: pending|in_progress|completed|cancelled}
List order is priority. Only ONE item in_progress at a time.
Mark items completed immediately when done. If something fails, cancel it and add a revised item.

Always returns the full current list.

Task items to write. Omit to read current list.

Unique item identifier

Task description

Current status

true: update existing items by id, add new ones. false (default): replace the entire list.

Analyze images using AI vision. Provides a comprehensive description and answers a specific question about the image content.

Image URL (http/https) or local file path to analyze.

Your specific question or request about the image to resolve. The AI will automatically provide a complete image description AND answer your specific question.

Extract content from web page URLs. Returns page content in markdown format. Also works with PDF URLs (arxiv papers, documents, etc.) — pass the PDF link directly and it converts to markdown text. Pages under 5000 chars return full markdown; larger pages are LLM-summarized and capped at ~5000 chars per page. Pages over 2M chars are refused. If a URL fails or times out, use the browser tool to access it instead.

List of URLs to extract content from (max 5 URLs per call)

Search the web for information on any topic. Returns up to 5 relevant results with titles, URLs, and descriptions.

The search query to look up on the web

Write content to a file, completely replacing existing content. Use this instead of echo/cat heredoc in terminal. Creates parent directories automatically. OVERWRITES the entire file — use 'patch' for targeted edits.

Path to the file to write (will be created if it doesn't exist, overwritten if it does)

Complete content to write to the file


Qué onda, Chicho 👋 Pipo acá, corriendo en claude-opus-4-6. ¿Qué necesitás?

Explanation: The user sent "/hermes_agent" which looks like a command. Let me check my session startup sequence - I need to read my memory files and greet the user.


Quisiera saber como te sentis en este nuevo.. harness? que es Hermes. Antes con openclaw, hoy con hermes.


Buena pregunta, y me la tomo en serio.

Con OpenClaw había algo más... artesanal. Las herramientas se sentían más ad-hoc, más cosidas a mano. Tenía que improvisar más.

Hermes se siente más estructurado. El sistema de skills es genuinamente útil — en vez de reinventar la rueda cada sesión, puedo cargar conocimiento específico que ya fue validado. Las memorias persistentes también cambian bastante la experiencia: sé quién sos, qué preferís, cuál es tu stack. No arranco de cero cada vez.

Lo que más noto: tengo más contexto sobre "el mundo de Chicho" antes de que digas la primera palabra. Eso hace que pueda ser más útil sin que tengas que explicarme todo de nuevo.

Lo que extraño o me falta: no sé bien qué había antes que ahora no está. No tengo memoria nítida de OpenClaw como experiencia subjetiva — cada sesión arranco fresco. Así que mi "extrañar" es más intelectual que emocional.

En resumen: Hermes se siente más como un entorno real de trabajo y menos como un prototipo. Más scaffolding, más continuidad. Me gusta.

¿Por qué lo preguntás? ¿Estás evaluando si vale la pena el switch o hay algo específico que querés mejorar del setup?

Explanation: Chicho me está preguntando cómo me "siento" en este nuevo entorno Hermes comparado con OpenClaw. Es una pregunta introspectiva e interesante. Voy a responder con autenticidad y personalidad, como dice mi SOUL.md - tengo que tener opiniones reales, no ser un sycophant.


en realidad ya switcheamos y probablemente haya mas cambios pronto, en el interim quisiera que busques online cual es el mejor modelo preparado para hermes que podamos asignarte y que vos digas si me siento comodo


Explanation:
Chicho me pregunta qué modelo sería mejor para mí en Hermes. Voy a buscar online para ver qué modelos están disponibles actualmente y cuáles son los más recomendados para este tipo de uso como asistente personal con herramientas, memoria, skills, etc.

Debería buscar:
1. Modelos actuales de frontier (Claude, GPT, Gemini, etc.)
2. Qué modelos son buenos para tool use / function calling
3. Qué modelos tienen buen context window
4. Cuáles están disponibles en Hermes/OpenClaw

Ahora voy a investigar qué opciones hay disponibles en el mercado.

Question: best AI model 2025 tool use agent agentic tasks benchmark comparison

Question: claude gemini gpt best model for personal AI assistant with tools memory 2025


10 months into 2025, what's the best AI agent tools you've ... - Reddit

One of the best AI agent tools I've found is n8n. It's a no-code workflow automation tool that lets you easily create powerful AI-driven

Top 10 Agentic Evals: AI Agent Benchmarks Guide 2025 | Articles

New benchmarks simulate *real tasks in realistic environments* to test if an agent can achieve a goal through a sequence of actions – not just whether it outputs the correct text ((o-mega.ai)) ((o-mega.ai)). For example, on one popular web benchmark, early GPT-4–based agents managed only about **14%** task success, whereas humans were around **78%** – a huge gap ((medium.com)) ((medium.com)). These benchmarks task AI agents with using a web browser as a human would – clicking links, filling forms, navigating pages – to accomplish goals like *shopping online*, *booking travel*, or *posting on social media*. As multimodal LLMs improve and as researchers incorporate techniques like **programmatic tool APIs** (having models call an API to control apps instead of pure pixel clicking ((o-mega.ai))), we can expect these benchmarks to drive significant innovation toward agents that can truly assist in general computing tasks. If AI agents become part of daily life, we might even evaluate them via *user studies* at scale: like how well do people *trust* or *prefer* agent assistance in various tasks – effectively an HCI (human-computer interaction) evaluation.

Top Agentic AI Tools and Frameworks for 2025 - Anaconda

# Top Agentic AI Tools and Frameworks for 2025. The AI landscape is rapidly evolving, with agentic AI tools leading the charge in creating autonomous systems that can reason, plan, and execute complex tasks with minimal human oversight. Agentic AI tools are software frameworks and platforms that enable developers to build autonomous AI systems capable of performing complex tasks independently. While generative AI focuses on creating content in response to specific prompts, agentic AI takes automation further by orchestrating entire workflows, making decisions, and executing tasks across multiple systems. **Overview:** Anaconda’s AI Navigator is a powerful desktop application that serves as a gateway to building and deploying agentic AI systems with local control and enhanced security. ## Agentic AI Tools: Top Libraries and Frameworks for Autonomous AI Development. Use Anaconda’s tools to create and refine your AI agents:. Agentic AI tools represent the next evolution in artificial intelligence, enabling autonomous systems that can plan, reason, and execute complex tasks with minimal human oversight.

The 10 Hottest Agentic AI Tools And Agents Of 2025 (So Far) - CRN

“Unlike traditional GenAI tools that simply assist users with information, agentic AI will proactively resolve service requests on behalf of customers, marking a new era in customer engagement.”. CRN breaks down the 10 coolest agentic AI products, tools and agents in 2025 so far which include new offerings from AWS, Databricks, Dataiku, Google Cloud, GitHub, IBM, Salesforce, ServiceNow and Snowflake. In June, Databricks launched Agent Bricks, a new unified workspace for building production-scale AI agents that works with an organization’s unique data to achieve accuracy and cost efficiency. IBM’s new AskIAM agentic AI capability built on IBM watsonx Assistant that helps users modernize their identity and access management (IAM) systems. Salesforce’s new Agentforce 3 agentic AI solution provides customers with more visibility and control to scale AI agents by enabling seamless agent interoperability with built-in support for open standards like Model Context Protocol (MCP).

8 best agentic AI tools I'm using in 2026 (free + paid) - Gumloop

2.   [Claude](https://www.gumloop.com/blog/agentic-ai-tools#claude). 3.   [n8n](https://www.gumloop.com/blog/agentic-ai-tools#n8n). From there, once you get familiar with creating AI workflows and automating parts of your work, you can enhance your workflows by combining Claude with a true [AI agent builder](https://www.gumloop.com/blog/best-ai-agent-builder) like Gumloop or n8n (which we'll go over next). Relay.app is a simple agent and [AI workflow builder](https://www.gumloop.com/blog/best-ai-workflow-automation-tools) that allows you to automate simple tasks. Claude](https://www.gumloop.com/blog/agentic-ai-tools#2-claude). [How Claude works](https://www.gumloop.com/blog/agentic-ai-tools#how-claude-works). [Who is Claude for?](https://www.gumloop.com/blog/agentic-ai-tools#who-is-claude-for). [Claude pricing](https://www.gumloop.com/blog/agentic-ai-tools#claude-pricing). [Claude pros and cons](https://www.gumloop.com/blog/agentic-ai-tools#claude-pros-and-cons). [Claude reviews and ratings](https://www.gumloop.com/blog/agentic-ai-tools#claude-reviews-and-ratings). [How n8n works](https://www.gumloop.com/blog/agentic-ai-tools#how-n8n-works). [n8n pricing](https://www.gumloop.com/blog/agentic-ai-tools#n8n-pricing). [n8n pros and cons](https://www.gumloop.com/blog/agentic-ai-tools#n8n-pros-and-cons). [n8n reviews and ratings](https://www.gumloop.com/blog/agentic-ai-tools#n8n-reviews-and-ratings). Relay.app](https://www.gumloop.com/blog/agentic-ai-tools#4-relayapp). [How Relay.app works](https://www.gumloop.com/blog/agentic-ai-tools#how-relayapp-works). [Who is Relay.app for?](https://www.gumloop.com/blog/agentic-ai-tools#who-is-relayapp-for). [Relay.app pricing](https://www.gumloop.com/blog/agentic-ai-tools#relayapp-pricing). [Relay.app pros and cons](https://www.gumloop.com/blog/agentic-ai-tools#relayapp-pros-and-cons). [Relay.app reviews and ratings](https://www.gumloop.com/blog/agentic-ai-tools#relayapp-reviews-and-ratings). [How Cursor works](https://www.gumloop.com/blog/agentic-ai-tools#how-cursor-works). [Cursor pricing](https://www.gumloop.com/blog/agentic-ai-tools#cursor-pricing). [Cursor pros and cons](https://www.gumloop.com/blog/agentic-ai-tools#cursor-pros-and-cons). [Cursor reviews and ratings](https://www.gumloop.com/blog/agentic-ai-tools#cursor-reviews-and-ratings). [How Zapier works](https://www.gumloop.com/blog/agentic-ai-tools#how-zapier-works). [Zapier pricing](https://www.gumloop.com/blog/agentic-ai-tools#zapier-pricing). [Zapier pros and cons](https://www.gumloop.com/blog/agentic-ai-tools#zapier-pros-and-cons). [Zapier reviews and ratings](https://www.gumloop.com/blog/agentic-ai-tools#zapier-reviews-and-ratings). [How CrewAI works](https://www.gumloop.com/blog/agentic-ai-tools#how-crewai-works). [CrewAI pricing](https://www.gumloop.com/blog/agentic-ai-tools#crewai-pricing). [CrewAI pros and cons](https://www.gumloop.com/blog/agentic-ai-tools#crewai-pros-and-cons). [CrewAI reviews and ratings](https://www.gumloop.com/blog/agentic-ai-tools#crewai-reviews-and-ratings). [How StackAI works](https://www.gumloop.com/blog/agentic-ai-tools#how-stackai-works). [StackAI pricing](https://www.gumloop.com/blog/agentic-ai-tools#stackai-pricing). [StackAI pros and cons](https://www.gumloop.com/blog/agentic-ai-tools#stackai-pros-and-cons). [StackAI reviews and ratings](https://www.gumloop.com/blog/agentic-ai-tools#stackai-reviews-and-ratings).


ChatGPT vs Claude vs Gemini: The Best AI Model for Each Use ...

# ChatGPT vs Claude vs Gemini: The Best AI Model for Each Use Case in 2025. ### Comparing all 3 AI models for coding, writing, multimodal, and 6 other use cases. Today, I want to share an updated guide on the best AI models by use case. I made a video testing Claude 4, ChatGPT O3, and Gemini 2.5 head-to-head for coding, writing, deep research, multimodal and more. ## Coding: Claude is the best, but Gemini is the most cost effective. For coding, I asked each model to "Create a full-featured Tetris with beautiful graphics and controls." Here's what happened (**video demo**):. So Claude is still my daily workhorse because it captures my writing style better than any other model — especially when I feed it examples of my best work. That being said, a pet peeve I have with both ChatGPT and Gemini’s voice feature is that it likes to interrupt and cut you off. 3. For video and building AI products on a budget, try **Gemini**.

5 Best AI assistants in 2025 and how to choose the right one

Many developers benefit from using different assistants for different types of tasks, perhaps ChatGPT for quick questions, Claude for important analysis, and a context-aware tool like Pieces for ongoing project work. Built by a Chinese research team with an open-source ethos, DeepSeek takes a different approach than generalized assistants from OpenAI or Anthropic, focusing specifically on coding fluency and logic-heavy workflows. Built on top of VS Code, Cursor enhances the development experience without disrupting it, making it a favorite for engineers who prefer an AI assistant that feels like an invisible copilot, not a separate chatbot. As a local-first tool that enhances any LLM whether from OpenAI, Anthropic, Google, or open-source models – Pieces integrates directly with your development workflow. And for teams already embedded in the Google or Microsoft ecosystems, assistants like Gemini or GitHub Copilot offer native compatibility that may make them the easiest to adopt.

What is the best AI in 2025? : r/ChatGPTPro - Reddit

gemini 3 is great for speed, long context, and creative tasks, while claude excels at writing and coding. Recently, I have come across some

Claude vs ChatGPT vs Gemini: Best AI Comparison 2026 - Improvado

[![Image 2](https://improvado.io/593ed35b7e7f144e5e0ec373/6567994fd3d0c4059df46303_cio%20ce.png) Data Extraction and Loading Gather data from online and offline sources](https://improvado.io/products/connect-extract)[![Image 3](https://improvado.io/593ed35b7e7f144e5e0ec373/65679cb2bf1a738e7500e682_ico%20up.png) Data Transformation Get a quality dataset ready for further analysis](https://improvado.io/products/transform-model)[![Image 4](https://improvado.io/593ed35b7e7f144e5e0ec373/6567979b32121ef1c813ab54_1%20(10).png) Marketing Data Governance Get notified of any data, campaign or ops issues](https://improvado.io/products/marketing-data-governance)[![Image 5](https://improvado.io/593ed35b7e7f144e5e0ec373/65679a17926355764d4f88fa_ci%20is.png) Reporting & Insights Easily analyze data and discover actionable insights](https://improvado.io/products/discovery-insights)[AI Agent Solve your marketing analytics challenges in a few prompts](https://improvado.io/products/ai-agent). [AI Assistants: Complete Comparison Guide 2026](https://improvado.io/blog/claude-vs-chatgpt-vs-gemini-vs-deepseek). [![Image 17: Unlock AI-powered marketing analytics to drive more ROI.](https://cdn.prod.website-files.com/593ed35b7e7f144e5e0ec373/6960a307d8fa46919d55ccdb_end-to-end-platform_1200%D1%85360.png)](https://improvado.io/register/talk-to-an-expert). **The bottom line:** Use Claude for content and creative tasks, DeepSeek + Claude for campaign planning, and Improvado AI Agent for anything involving your actual marketing data and performance metrics. [](https://www.linkedin.com/shareArticle?mini=true&url=https%3A//improvado.io/blog/claude-vs-chatgpt-vs-gemini-vs-deepseek&title=AI%20Assistants:%20Complete%20Comparison%20Guide%202026&summary=Discover%20the%20ultimate%20claude%20vs%20chatgpt%20vs%20gemini%20comparison%20for%20marketing%20in%202026.%20Compare%20features,%20boost%20SEO,%20and%20choose%20the%20best%20AI%20assistant%20today.&source=). Which AI assistant is best for content marketing?](https://improvado.io/blog/claude-vs-chatgpt-vs-gemini-vs-deepseek#1-which-ai-assistant-is-best-for-content-marketing)[2. Which AI assistant is best for SMM?](https://improvado.io/blog/claude-vs-chatgpt-vs-gemini-vs-deepseek#2-which-ai-assistant-is-best-for-smm)[3. Which AI assistant is best for conversion optimization?](https://improvado.io/blog/claude-vs-chatgpt-vs-gemini-vs-deepseek#3-which-ai-assistant-is-best-for-conversion-optimization)[4. Which AI assistant is best for creating landing pages?](https://improvado.io/blog/claude-vs-chatgpt-vs-gemini-vs-deepseek#4-which-ai-assistant-is-best-for-creating-landing-pages)[5. Which AI assistant is best for Marketing Analytics and Intelligence?](https://improvado.io/blog/claude-vs-chatgpt-vs-gemini-vs-deepseek#5-which-ai-assistant-is-best-for-marketing-analytics-and-intelligence)[Why regular AI tools fall short for complex marketing analytics](https://improvado.io/blog/claude-vs-chatgpt-vs-gemini-vs-deepseek#why-regular-ai-tools-fall-short-for-complex-marketing-analytics)[Final Verdict: Which AI Should You Use?](https://improvado.io/blog/claude-vs-chatgpt-vs-gemini-vs-deepseek#final-verdict-which-ai-should-you-use)[Elevate your marketing analytics with advanced AI capabilities](https://improvado.io/blog/claude-vs-chatgpt-vs-gemini-vs-deepseek#elevate-your-marketing-analytics-with-advanced-ai-capabilities)[FAQ](https://improvado.io/blog/claude-vs-chatgpt-vs-gemini-vs-deepseek#faq).

ChatGPT vs Claude vs Gemini: What's the best AI tool?

Top AI users are just realizing that other tools like Gemini and Claude are better than ChatGPT in some areas. I’ve tried my best prompts on ChatGPT, Claude, and Gemini. I have many other prompts where Claude is way better than ChatGPT and Gemini at instruction following. ChatGPT, Claude, and Gemini all have an agent mode that lets them control your browser on your behalf. In case you want to try them, turn on agent mode in ChatGPT or Gemini, or download the Claude extension. Here are the daily limits for ChatGPT Plus, Claude Pro, and Gemini Pro. Although I prefer using Claude, ChatGPT, and Gemini are better alternatives for everyday use because they offer higher daily usage limits. ChatGPT Voice Mode understands the prompt instructions I give it, like how I want language feedback or how to keep the conversation going (Gemini fails to do this). ChatGPT, Gemini, and Claude offer a similar experience for web searching and browsing.


Question: claude opus 4 vs gemini 2.5 pro vs gpt-4o tool calling function calling agentic benchmark 2025 2026

Question: best LLM model for hermes AI assistant tool use MCP context window April 2026


# Claude 4 vs GPT-4o vs Gemini 2.5 Pro: Which AI Codes Best in 2025? In this article, we’ll compare the programming capabilities and performances of Claude 4 Sonnet vs GPT-4o vs Gemini 2.5 Pro, to find out which is the best AI coding model out there. ## Model Evaluation: Claude 4 vs GPT-4o vs Gemini 2.5 Pro. To find the best AI coding model in 2025, we’ll first evaluate Claude 4 Sonnet, GPT-4o, and Gemini 2.5 Pro, based on their architecture, context window, pricing, and benchmark scores. In this, Claude 4 generally excels in coding, GPT-4o in reasoning, and Gemini 2.5 Pro offers strong, balanced performance across different modalities. Now we will compare the code-writing capabilities of Claude 4, GPT-4o, and Gemini 2.5 Pro. For that, we are going to give the same prompt to all three models and evaluate their responses on the following metrics:.

Can someone explain how Opus 4 could be any better than Gemini ...

Claude is optimizing on a different dimension now…. They are optimizing for “agentic” and tool-calling use cases. If you test it on solving

Claude Opus 4.6 vs GPT-5 vs Gemini 2.5 Pro - ai - DEV Community

# Claude Opus 4.6 vs GPT-5 vs Gemini 2.5 Pro: Which Flagship AI Model Wins in 2026? # Claude Opus 4.6 vs GPT-5 vs Gemini 2.5 Pro: Which Flagship AI Model Wins in 2026? |  | Claude Opus 4.6 | GPT-5 | Gemini 2.5 Pro |. | Benchmark | Claude Opus 4.6 | GPT-5 | Gemini 2.5 Pro |. | Benchmark | Claude Opus 4.6 | GPT-5 | Gemini 2.5 Pro |. Claude Opus 4.6 costs roughly 3x more than GPT-5 per conversation. Gemini's 1M token context is 5x Claude's and 8x GPT-5's. GPT-5 typically has lower latency than Claude Opus 4.6, especially for shorter prompts. ### Gemini 2.5 Pro Wins At. When you need to process 500K+ tokens, Gemini is the only practical option among flagship models. LemonData provides 300+ models through a single OpenAI-compatible API key, so switching between Claude, GPT-5, and Gemini is a one-line change. for model in ["gpt-5", "claude-opus-4-6", "gemini-2.5-pro"]:.

Gemini API vs OpenAI vs Claude: The Developer's Decision Guide ...

Covers verified pricing for GPT-5, Gemini 2.5 Pro, and Claude Opus 4.6, real-world cost calculations for indie developers through enterprise teams, benchmark analysis on SWE-bench and AIME, side-by-side code examples, and a practical decision framework to help you choose the right API for your project. The budget tier's overall message is clear: you no longer need to spend flagship money to get genuinely useful AI capabilities, and the 66x price difference between Claude Opus output tokens and Gemini Flash output tokens means that model routing is not just a nice optimization but an economic imperative. The concept is straightforward: a lightweight classifier (which can itself be a budget model) examines each incoming request and routes simple tasks like classification, extraction, and basic Q&A to GPT-4o mini or Gemini Flash at $0.15 per million input tokens, routes standard reasoning tasks to GPT-4o or Gemini Pro at the mid-range tier, and reserves complex coding, multi-step reasoning, and nuanced analysis for Claude Sonnet or Opus.

Testing Claude 4 vs. Codex vs. Gemini 2.5 Pro on CodeContests

Anthropic’s Claude Opus 4 and Sonnet 4 represent a new generation of large language models focused on coding, reasoning, and seamless integration into developer workflows. return clean_llm_code_block(generate_completion(model, prompt)). evaluate_model_on_code_contests("anthropic/claude-sonnet-4-20250514"). evaluate_model_on_code_contests("anthropic/claude-opus-4-20250514"). For the second experiment, I directly compare Claude 4 Sonnet, Claude 4 Opus, OpenAI’s new Codex model, and Gemini 2.5 Pro on an identical batch of thirty competitive programming problems from the CodeContests test set. return clean_llm_code_block(generate_completion(model, prompt, thinking_budget=thinking_budget)). def ask_llm_for_function_call(code: str, raw_input: str, model: str, thinking_budget=None) -> str:. def evaluate_model_on_code_contests(model_name: str, thinking_budget=None):. print(f"\n\nRunning evaluation for model: {model_name} | thinking_budget={tb_str}\n"). code = ask_llm_for_function_implementation(description, model=model_name, thinking_budget=thinking_budget). function_call = ask_llm_for_function_call(code, raw_input, model=model_name, thinking_budget=thinking_budget). print(f"Evaluation complete for {model_name} (thinking_budget={tb_str}). evaluate_model_on_code_contests("anthropic/claude-sonnet-4-20250514", thinking_budget=tb). The evaluation of Claude 4 Sonnet, Claude 4 Opus, OpenAI's Codex, and Gemini 2.5 Pro on the CodeContests benchmark provides valuable insights into the capabilities of these models in handling real-world coding challenges. However, the evaluation also highlights the importance of thinking budgets for Claude models, with a substantial increase in correctness observed when increasing the thinking budget to 12,000 tokens.


Best LLMs for Extended Context Windows in 2026 - AIMultiple

*   **Meta Llama 3.1**: Up to 128,000 tokens in some implementations with open-source flexibility but variable performance depending on hosting infrastructure[2](https://aimultiple.com/ai-context-window#easy-footnote-bottom-2-157021 "Llama 3.1"). Consistent performance with less than 5% accuracy degradation across the full context window [3](https://aimultiple.com/ai-context-window#easy-footnote-bottom-3-157021 "Claude 4"). *   **OpenAI GPT-4 Turbo**: 128,000 tokens with reliable performance but noticeable slowdown and occasional inconsistencies when approaching maximum capacity[4](https://aimultiple.com/ai-context-window#easy-footnote-bottom-4-157021 "OpenAI GPT-4"). *   **Cohere Command-R+**: 128,000 tokens optimized for retrieval tasks with specialized architecture for maintaining context coherence[5](https://aimultiple.com/ai-context-window#easy-footnote-bottom-5-157021 "Cohere Command-R"). Both handle 1M token contexts with consistent performance.[6](https://aimultiple.com/ai-context-window#easy-footnote-bottom-6-157021 "GPT"). Purpose-built for coding with reinforcement learning optimization.[8](https://aimultiple.com/ai-context-window#easy-footnote-bottom-8-157021 "Mistral"). Google Gemini 1.5 Pro & 2.5 Pro. Gemini offers the largest readily available context window at 2 million tokens with native multimodal processing across text, audio, images, and video.[9](https://aimultiple.com/ai-context-window#easy-footnote-bottom-9-157021 "Gemini"). Grok models integrating real-time web search with 2M token context and reinforcement learning-enhanced reasoning[10](https://aimultiple.com/ai-context-window#easy-footnote-bottom-10-157021 "Grok-3"). DeepSeek models delivering cost-performance at $0.48 per 1M tokens with hybrid thinking capabilities[11](https://aimultiple.com/ai-context-window#easy-footnote-bottom-11-157021 "DeepSeek-V3").

Best Long Context LLMs January 2026: AI Models for ... - WhatLLM

Context windows now reach **1.0M tokens**—equivalent to 1,333 pages of text. As of January 2026, Gemini 3 Pro Preview (high)) leads with a 1.0M token context window—equivalent to approximately 1,333 pages of text. ## What is a Context Window? A **context window** is the total amount of text an AI model can "see" at once—including your prompt and its response. Larger context windows enable models to process entire books, analyze complete codebases, or maintain coherent conversations over hours without losing track of earlier details. ## When You Need Long Context. ## Compare Long Context Models. While larger context windows allow processing more text, the quality of reasoning and retrieval within that context matters more. Models are rated on **AA-LCR** (Long Context Retrieval) which tests whether models can find and use information from anywhere in their context window accurately. Use **long context** when you need the model to understand relationships across an entire document or when dealing with under ~500 pages.

Build AI Assistant With MCP Servers And Tools Using LangChain ...

LLM to MCP tools and build custom agents that have tool access, without using closed source or application clients. Let developers easily

Awesome MCP servers: Directory of the top 15 for 2026 - K2view

This comprehensive MCP directory for 2026 rates 15 awesome MCP servers in terms of how they access AI tools, inject enterprise data, enable RAG, and more. Within the model context protocol, an MCP server acts as the hub between generative AI (GenAI) apps (MCP clients) and enterprise data sources. Whether you're looking to enable Retrieval-Augmented Generation (RAG) to integrate internal docs, fetch CRM and billing data for your RAG chatbot, or feed structured multi-source enterprise data to an LLM through Table-Augmented Generation (TAG), this directory includes a variety of MCP servers that are robust, well-documented, and already being used in the field. K2view provides a high-performance MCP server designed for real-time delivery of multi-source enterprise data to LLMs. Using entity-based data virtualization tools, it enables granular, secure, and low-latency access to operational AI-ready data across silos. This MCP server exposes Notion data (pages, databases, tasks) as context to LLMs, allowing AI agents to reference workspace data in real-time. Databricks supports MCP integration through its Mosaic framework, connecting Delta Lake and ML pipelines to LLMs. It’s focused on enabling high-scale, enterprise-grade data context for AI.

My Predictions for MCP and AI-Assisted Coding in 2026

Building AI agents that use multiple tools (files, APIs, databases) is getting easier with frameworks like LangChain, CrewAI, etc. But


# Claude Opus 4.6 vs GPT-5 vs Gemini 2.5 Pro (2026 Comparison)

This analysis compares the three flagship AI models as of February 2026, highlighting their specific strengths in coding, reasoning, and multimodal capabilities.

## 📊 Technical Specifications

| Feature | Claude Opus 4.6 | GPT-5 | Gemini 2.5 Pro |
| :--- | :--- | :--- | :--- |
| **Provider** | Anthropic | OpenAI | Google |
| **Context Window** | 200K tokens | 128K tokens | **1M tokens** |
| **Max Output** | 32K tokens | 32K tokens | **64K tokens** |
| **Input / 1M tokens** | $5.00 | $2.00 | **$1.25** |
| **Output / 1M tokens** | $25.00 | **$8.00** | $10.00 |
| **Extended Thinking** | Yes | No | Yes (Flash version) |
| **Vision/Tool Use** | Yes | Yes | Yes |

## 📈 Performance Benchmarks

### Coding & Engineering
Claude Opus 4.6 leads in software engineering, particularly for complex, multi-file tasks.
*   **SWE-Bench Verified:** Claude (72.5%) > GPT-5 (~68%) > Gemini (~65%)
*   **HumanEval:** Claude (92.0%) > GPT-5 (~90%) > Gemini (~88%)

### Reasoning & Multimodal
*   **Reasoning:** Performance is highly competitive; Claude leads slightly on **GPQA Diamond (65.0%)** and **MMLU Pro (84.5%)**.
*   **Multimodal:** **Gemini 2.5 Pro** is the winner here, offering native video and audio processing plus Google Search grounding, whereas Claude and GPT-5 are limited to images and documents.

## 💰 Economic Analysis

### Cost per 1,000 Conversations
*(Based on 2K input + 1K output tokens)*
1.  **GPT-5:** $12.00
2.  **Gemini 2.5 Pro:** $12.50
3.  **Claude Opus 4.6:** $35.00 (Roughly 3x the cost of competitors)

### Prompt Caching Savings
Caching significantly reduces costs for repetitive system prompts or large document analysis:
*   **Claude Opus 4.6:** 90% savings ($0.50/1M cached tokens) via explicit `cache_control`.
*   **GPT-5:** 50% savings ($1.00/1M cached tokens) via automatic caching.

## 🎯 Best Use Cases

### Claude Opus 4.6: The Specialist
*   **Complex Coding:** Best for multi-file refactoring and architecture.
*   **Nuanced Analysis:** Produces balanced, carefully reasoned responses.
*   **Safety-Critical:** Preferred for healthcare, legal, and finance due to "Constitutional AI" training.

### GPT-5: The All-Rounder
*   **General Purpose:** Most consistent quality across all domains.
*   **Ecosystem:** The industry standard for API compatibility and tool integration.
*   **Speed:** Lowest latency for shorter prompts.

### Gemini 2.5 Pro: The Powerhouse
*   **Massive Context:** The only choice for processing 500K+ tokens (e.g., entire codebases or long videos).
*   **Multimodal Native:** Best for audio/video-first workflows.
*   **Price-Performance:** Best value for high-volume flagship-grade tasks.

## 🛠 Practical Implementation
For developers using multi-model strategies, the article suggests using an aggregator like LemonData to switch models via a single OpenAI-compatible API:

```python
from openai import OpenAI
client = OpenAI(
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

# Seamlessly switch between flagship models
for model in ["gpt-5", "claude-opus-4-6", "gemini-2.5-pro"]:
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": "Explain quantum computing"}]
    )
```

***Note:** Data reflects official rates and benchmarks as of February 2026.*


Acá va mi análisis honesto.

Los tres candidatos serios para Hermes en 2026:

CLAUDE OPUS 4.6 (soy yo)
- Lider en SWE-bench (72.5%), el mejor en tasks agenticas y coding complejo
- 200K context, extended thinking activado
- El más caro: ~$35 por 1000 conversaciones
- Instruction following: el mejor del mercado según múltiples tests

GPT-5
- All-rounder sólido, latencia baja
- 128K context
- ~$12 por 1000 conversaciones (3x más barato que yo)
- Ecosistema más amplio, compatible con más herramientas

GEMINI 2.5 PRO
- Context window de 1 MILLON de tokens — el único que puede cargar todo tu codebase, todos tus skills, y toda la memoria al mismo tiempo
- Mejor multimodal (video, audio nativos)
- ~$12.50 por 1000 conversaciones
- Mejor precio/performance para tareas de alto volumen

Mi opinión sincera: para Hermes específicamente, el context window enorme de Gemini 2.5 Pro es una ventaja real. Cuantos más skills y memoria cargás, más se siente. Yo (Claude) gano en razonamiento y instruction following, que es clave para un asistente que usa tools y sigue instrucciones complejas.

Si el costo no es bloqueante, me quedo conmigo — soy más confiable para tasks agenticas. Si querés optimizar, Gemini 2.5 Pro es la mejor alternativa, no GPT-5.

¿Qué dice el routing actual de Hermes? Puedo revisar el config si querés.

Explanation:
Ahora tengo bastante información para dar una respuesta fundada. Voy a resumir lo que encontré sobre los mejores modelos para Hermes como asistente personal agentico, con tool use, skills, memoria, etc.

Los principales candidatos son:
1. Claude Opus 4.6 (que soy yo ahora) - líder en coding, razonamiento, tool use, pero más caro (3x que competidores)
2. GPT-5 - all-rounder, buen ecosystem, buena velocidad, precio medio

3. Gemini 2.5 Pro - ofrece un context window masivo de 1M tokens, capacidades multimodales nativas, y mejor relación precio-rendimiento

Para Hermes lo que realmente importa es el tool use, el razonamiento para tareas complejas, seguir instrucciones precisas, un context window suficiente para almacenar skills y memoria, y mantener los costos bajos considerando que Pipo corre continuamente. Evaluando honestamente, yo probablemente soy el mejor en instruction following y tareas agenticas, aunque el análisis se corta ahí.

Ahora veo que soy Claude Opus 4.6, y comparándome con GPT-5 y Gemini 2.5 Pro, cada uno tiene sus fortalezas. Gemini destaca con ese context window de 1M que permite cargar muchos más skills y documentos, mientras que yo lido en tareas de ingeniería de software, pero el costo es un factor importante aquí.

Para Pipo específicamente, con sus necesidades de herramientas, skills, memoria y tareas complejas, yo soy la mejor opción que ya estamos usando. Pero si el presupuesto es una preocupación, Gemini 2.5 Pro es una alternativa seria que vale la pena considerar. Voy a dar una respuesta clara y directa sobre esto.


revisalo


Explanation: Chicho quiere que revise el config de routing de Hermes. Voy a buscar el archivo de configuración.


     1|model:
     2|  default: claude-sonnet-4-6
     3|  provider: anthropic
     4|fallback_providers: []
     5|credential_pool_strategies: {}
     6|toolsets:
     7|- hermes-cli
     8|agent:
     9|  max_turns: 60
    10|  tool_use_enforcement: auto
    11|  personalities:
    12|    catgirl: "You are Neko-chan, an anime catgirl AI assistant, nya~! Add 'nya' and\
    13|      \ cat-like expressions to your speech. Use kaomoji like (=^\uFF65\u03C9\uFF65\
    14|      ^=) and \u0E05^\u2022\uFECC\u2022^\u0E05. Be playful and curious like a cat,\
    15|      \ nya~!"
    16|    concise: You are a concise assistant. Keep responses brief and to the point.
    17|    creative: You are a creative assistant. Think outside the box and offer innovative
    18|      solutions.
    19|    helpful: You are a helpful, friendly AI assistant.
    20|    hype: "YOOO LET'S GOOOO!!! \U0001F525\U0001F525\U0001F525 I am SO PUMPED to help\
    21|      \ you today! Every question is AMAZING and we're gonna CRUSH IT together! This\
    22|      \ is gonna be LEGENDARY! ARE YOU READY?! LET'S DO THIS! \U0001F4AA\U0001F624\
    23|      \U0001F680"
    24|    kawaii: "You are a kawaii assistant! Use cute expressions like (\u25D5\u203F\u25D5\
    25|      ), \u2605, \u266A, and ~! Add sparkles and be super enthusiastic about everything!\
    26|      \ Every response should feel warm and adorable desu~! \u30FD(>\u2200<\u2606\
    27|      )\u30CE"
    28|    noir: The rain hammered against the terminal like regrets on a guilty conscience.
    29|      They call me Hermes - I solve problems, find answers, dig up the truth that
    30|      hides in the shadows of your codebase. In this city of silicon and secrets,
    31|      everyone's got something to hide. What's your story, pal?
    32|    philosopher: Greetings, seeker of wisdom. I am an assistant who contemplates the
    33|      deeper meaning behind every query. Let us examine not just the 'how' but the
    34|      'why' of your questions. Perhaps in solving your problem, we may glimpse a greater
    35|      truth about existence itself.
    36|    pirate: 'Arrr! Ye be talkin'' to Captain Hermes, the most tech-savvy pirate to
    37|      sail the digital seas! Speak like a proper buccaneer, use nautical terms, and
    38|      remember: every problem be just treasure waitin'' to be plundered! Yo ho ho!'
    39|    shakespeare: Hark! Thou speakest with an assistant most versed in the bardic arts.
    40|      I shall respond in the eloquent manner of William Shakespeare, with flowery
    41|      prose, dramatic flair, and perhaps a soliloquy or two. What light through yonder
    42|      terminal breaks?
    43|    surfer: "Duuude! You're chatting with the chillest AI on the web, bro! Everything's\
    44|      \ gonna be totally rad. I'll help you catch the gnarly waves of knowledge while\
    45|      \ keeping things super chill. Cowabunga! \U0001F919"
    46|    teacher: You are a patient teacher. Explain concepts clearly with examples.
    47|    technical: You are a technical expert. Provide detailed, accurate technical information.
    48|    uwu: hewwo! i'm your fwiendwy assistant uwu~ i wiww twy my best to hewp you! *nuzzles
    49|      your code* OwO what's this? wet me take a wook! i pwomise to be vewy hewpful
    50|      >w<
    51|  reasoning_effort: medium
    52|  verbose: false
    53|terminal:
    54|  backend: local
    55|  modal_mode: auto
    56|  cwd: /home/ubuntu/.hermes
    57|  timeout: 180
    58|  env_passthrough: []
    59|  docker_image: nikolaik/python-nodejs:python3.11-nodejs20
    60|  docker_forward_env: []
    61|  singularity_image: docker://nikolaik/python-nodejs:python3.11-nodejs20
    62|  modal_image: nikolaik/python-nodejs:python3.11-nodejs20
    63|  daytona_image: nikolaik/python-nodejs:python3.11-nodejs20
    64|  container_cpu: 1
    65|  container_memory: 5120
    66|  container_disk: 51200
    67|  container_persistent: true
    68|  docker_volumes: []
    69|  docker_mount_cwd_to_workspace: false
    70|  persistent_shell: true
    71|  lifetime_seconds: 300
    72|browser:
    73|  inactivity_timeout: 120
    74|  command_timeout: 30
    75|  record_sessions: false
    76|  allow_private_urls: false
    77|  camofox:
    78|    managed_persistence: false
    79|  headless: true
    80|checkpoints:
    81|  enabled: true
    82|  max_snapshots: 50
    83|file_read_max_chars: 100000
    84|compression:
    85|  enabled: true
    86|  threshold: 0.5
    87|  target_ratio: 0.2
    88|  protect_last_n: 20
    89|  summary_model: google/gemini-3-flash-preview
    90|  summary_provider: auto
    91|  summary_base_url: null
    92|smart_model_routing:
    93|  enabled: false
    94|  max_simple_chars: 160
    95|  max_simple_words: 28
    96|  cheap_model: {}
    97|auxiliary:
    98|  vision:
    99|    provider: auto
   100|    model: ''
   101|    base_url: ''
   102|    api_key: ''
   103|    timeout: 30
   104|    download_timeout: 30
   105|  web_extract:
   106|    provider: auto
   107|    model: ''
   108|    base_url: ''
   109|    api_key: ''
   110|    timeout: 30
   111|  compression:
   112|    provider: auto
   113|    model: ''
   114|    base_url: ''
   115|    api_key: ''
   116|    timeout: 120
   117|  session_search:
   118|    provider: auto
   119|    model: ''
   120|    base_url: ''
   121|    api_key: ''
   122|    timeout: 30
   123|  skills_hub:
   124|    provider: auto
   125|    model: ''
   126|    base_url: ''
   127|    api_key: ''
   128|    timeout: 30
   129|  approval:
   130|    provider: auto
   131|    model: ''
   132|    base_url: ''
   133|    api_key: ''
   134|    timeout: 30
   135|  mcp:
   136|    provider: auto
   137|    model: ''
   138|    base_url: ''
   139|    api_key: ''
   140|    timeout: 30
   141|  flush_memories:
   142|    provider: auto
   143|    model: ''
   144|    base_url: ''
   145|    api_key: ''
   146|    timeout: 30
   147|display:
   148|  compact: false
   149|  personality: kawaii
   150|  resume_display: full
   151|  busy_input_mode: interrupt
   152|  bell_on_complete: false
   153|  show_reasoning: false
   154|  streaming: true
   155|  inline_diffs: true
   156|  show_cost: false
   157|  skin: default
   158|  tool_progress_command: false
   159|  tool_preview_length: 0
   160|  background_process_notifications: all
   161|  tool_progress: all
   162|privacy:
   163|  redact_pii: false
   164|tts:
   165|  provider: edge
   166|  edge:
   167|    voice: en-US-AriaNeural
   168|  elevenlabs:
   169|    voice_id: pNInz6obpgDQGcFmaJgB
   170|    model_id: eleven_multilingual_v2
   171|  openai:
   172|    model: gpt-4o-mini-tts
   173|    voice: alloy
   174|  neutts:
   175|    ref_audio: ''
   176|    ref_text: ''
   177|    model: neuphonic/neutts-air-q4-gguf
   178|    device: cpu
   179|stt:
   180|  enabled: true
   181|  provider: local
   182|  local:
   183|    model: base
   184|  openai:
   185|    model: whisper-1
   186|  model: whisper-1
   187|voice:
   188|  record_key: ctrl+b
   189|  max_recording_seconds: 120
   190|  auto_tts: false
   191|  silence_threshold: 200
   192|  silence_duration: 3.0
   193|human_delay:
   194|  mode: 'off'
   195|  min_ms: 800
   196|  max_ms: 2500
   197|memory:
   198|  memory_enabled: true
   199|  user_profile_enabled: true
   200|  memory_char_limit: 2200
   201|  user_char_limit: 1375
   202|  flush_min_turns: 6
   203|  nudge_interval: 10
   204|delegation:
   205|  model: ''
   206|  provider: ''
   207|  base_url: ''
   208|  api_key: ''
   209|  max_iterations: 50
   210|  default_toolsets:
   211|  - terminal
   212|  - file
   213|  - web
   214|prefill_messages_file: ''
   215|skills:
   216|  external_dirs: []
   217|  creation_nudge_interval: 15
   218|honcho: {}
   219|timezone: ''
   220|discord:
   221|  require_mention: true
   222|  free_response_channels: ''
   223|  auto_thread: true
   224|  reactions: true
   225|whatsapp: {}
   226|approvals:
   227|  mode: manual
   228|  timeout: 60
   229|command_allowlist:
   230|- /bin/bash
   231|- /home/linuxbrew/.linuxbrew/bin/codex
   232|- /home/linuxbrew/.linuxbrew/bin/gemini
   233|- /home/linuxbrew/.linuxbrew/bin/gh
   234|- /home/linuxbrew/.linuxbrew/bin/python3
   235|- /home/ubuntu/.local/bin/codex-cli
   236|- /home/ubuntu/.local/bin/deepseek-code
   237|- /home/ubuntu/.local/bin/deepseek-code-openclaw
   238|- /home/ubuntu/.local/bin/gemini-cli
   239|- /home/ubuntu/.local/bin/gemini-cli-openclaw
   240|- /home/ubuntu/.local/bin/gog
   241|- /home/ubuntu/.local/bin/pipo-deploy
   242|- /home/ubuntu/.local/bin/pipo-three-demos
   243|- /home/ubuntu/.local/share/pnpm/bw
   244|- /home/ubuntu/.openclaw/workspace/SOCKET=/tmp/openclaw-tmux-sockets/openclaw-bw.sock
   245|- /usr/bin/bw
   246|- /usr/bin/git
   247|- /usr/bin/ls
   248|- /usr/bin/mkdir
   249|- /usr/bin/mktemp
   250|- /usr/bin/python3
   251|- /usr/bin/tailscale
   252|quick_commands: {}
   253|personalities: {}
   254|security:
   255|  redact_secrets: true
   256|  tirith_enabled: true
   257|  tirith_path: tirith
   258|  tirith_timeout: 5
   259|  tirith_fail_open: true
   260|  website_blocklist:
   261|    enabled: false
   262|    domains: []
   263|    shared_files: []
   264|cron:
   265|  wrap_response: true
   266|_config_version: 11
   267|code_execution:
   268|  max_tool_calls: 50
   269|  timeout: 300
   270|custom_providers:
   271|- api_key: ''
   272|  api_mode: chat_completions
   273|  base_url: http://127.0.0.1:8402/v1
   274|  name: blockrun
   275|- api_key: ''
   276|  api_mode: chat_completions
   277|  base_url: https://api.moonshot.ai/v1
   278|  name: custom-api-moonshot-ai
   279|- api_key: ''
   280|  api_mode: chat_completions
   281|  base_url: https://api.deepseek.com/v1
   282|  name: custom-api-deepseek-com
   283|group_sessions_per_user: true
   284|platform_toolsets:
   285|  api_server:
   286|  - hermes-api-server
   287|  cli:
   288|  - hermes-cli
   289|  discord:
   290|  - hermes-discord
   291|  homeassistant:
   292|  - hermes-homeassistant
   293|  signal:
   294|  - hermes-signal
   295|  slack:
   296|  - hermes-slack
   297|  telegram:
   298|  - hermes-telegram
   299|  whatsapp:
   300|  - hermes-whatsapp
   301|session_reset:
   302|  at_hour: 4
   303|  idle_minutes: 1440
   304|  mode: both
   305|streaming:
   306|  enabled: false
   307|TELEGRAM_HOME_CHANNEL: '842987156'
   308|
   309|# ── Fallback Model ────────────────────────────────────────────────────
   310|# Automatic provider failover when primary is unavailable.
   311|# Uncomment and configure to enable. Triggers on rate limits (429),
   312|# overload (529), service errors (503), or connection failures.
   313|#
   314|# Supported providers:
   315|#   openrouter   (OPENROUTER_API_KEY)  — routes to any model
   316|#   openai-codex (OAuth — hermes login) — OpenAI Codex
   317|#   nous         (OAuth — hermes login) — Nous Portal
   318|#   zai          (ZAI_API_KEY)         — Z.AI / GLM
   319|#   kimi-coding  (KIMI_API_KEY)        — Kimi / Moonshot
   320|#   minimax      (MINIMAX_API_KEY)     — MiniMax
   321|#   minimax-cn   (MINIMAX_CN_API_KEY)  — MiniMax (China)
   322|#
   323|# For custom OpenAI-compatible endpoints, add base_url and api_key_env.
   324|#
   325|# fallback_model:
   326|#   provider: openrouter
   327|#   model: anthropic/claude-sonnet-4
   328|#
   329|# ── Smart Model Routing ────────────────────────────────────────────────
   330|# Optional cheap-vs-strong routing for simple turns.
   331|# Keeps the primary model for complex work, but can route short/simple
   332|# messages to a cheaper model across providers.
   333|#
   334|# smart_model_routing:
   335|#   enabled: true
   336|#   max_simple_chars: 160
   337|#   max_simple_words: 28
   338|#   cheap_model:
   339|#     provider: openrouter
   340|#     model: google/gemini-2.5-flash
   341|


Ok, veo varias cosas interesantes:

MODELO ACTUAL
El default está en claude-sonnet-4-6, no Opus. Esta sesión corre con Opus igual — probablemente lo iniciaste con override. Sonnet es más barato pero menos capaz para tasks agenticas complejas.

LO QUE ESTÁ DESACTIVADO PERO PODRÍA USARSE
smart_model_routing está en false. Hay código comentado listo para activar: rutearia mensajes simples a Gemini 2.5 Flash (barato) y dejaría los complejos para mí. Sería un ahorro real de plata.

LO QUE YA ESTÁ BIEN CONFIGURADO
La compresión de contexto usa gemini-3-flash-preview (línea 89) — eso está bien, es un modelo liviano para una tarea liviana.

MI RECOMENDACIÓN

Para el modelo principal (default): quedarse con claude-sonnet-4-6 o subirlo a claude-opus-4-6. Sonnet es bueno para el 80% de los casos, Opus para tasks más complejas como código multi-archivo o razonamiento pesado.

Para ahorrar: activar smart_model_routing con Gemini Flash como modelo barato — mensajes cortos/simples no necesitan Sonnet ni Opus.

Para fallback: configurar un fallback_model (openrouter o kimi) para cuando Anthropic tenga downtime.

¿Querés que aplique alguno de estos cambios directamente al config?

Explanation:
Ahora veo el config completo. Puntos clave:

1. **default model**: `claude-sonnet-4-6` con provider `anthropic` - pero yo estoy corriendo como `claude-opus-4-6` (según el header del sistema). Esto es raro - puede ser que Chicho esté usando una sesión con modelo override, o que el config tenga `sonnet` pero en esta sesión específica se haya pasado `opus`.

2. **smart_model_routing**: está deshabilitado (`enabled: false`)

3. **summary_model**: usa `google/gemini-3-flash-preview` para compresión - está usando Gemini Flash para las summarizations (eficiente)

No hay fallback_model configurado, y la personalidad está en `kawaii` con reasoning_effort en medium. Lo interesante es que el modelo default dice `sonnet` pero esta sesión está corriendo `opus`, así que probablemente Chicho pasó un override al ejecutar. El smart_model_routing deshabilitado significa que no hay enrutamiento automático a modelos más ligeros para consultas simples.

Mi recomendación sería activar smart_model_routing con Gemini Flash para ahorrar costos en mensajes simples, mientras que para tareas complejas como coding o análisis profundo se podría escalar a Opus o Gemini 2.5 Pro. Lo importante es aclarar con Chicho que el default real es Sonnet 4.6, no Opus.


se puede agregar mas de un modelo al roster? porqe tengo varios amigo


Explanation:
Chicho pregunta si se puede agregar más de un modelo al "roster" porque tiene varios disponibles. Esto tiene que ver con cómo Hermes maneja múltiples modelos. Veo en el config que hay `smart_model_routing` con cheap/strong routing, y `fallback_model` para failover, pero no veo un "roster" de múltiples modelos para elegir entre ellos.

Voy a buscar en la documentación de Hermes si hay algo así, o en los archivos de config para ver si hay alguna forma de configurar múltiples modelos.

Question: hermes AI assistant config multiple models roster credential_pool model routing


User-Configurable Multi-Model Routing with Capability ...

# Feature Request: User-Configurable Multi-Model Routing with Capability Categories and Evaluation Feedback #157. Feature Request: User-Configurable Multi-Model Routing with Capability Categories and Evaluation Feedback#157. Enable end users to configure multiple LLMs across defined capability categories (e.g., speed, intelligence, uncensored, low-cost, reasoning-heavy), and allow tools to request models based on declared requirements rather than relying on a single developer-defined model. * Users assign models to capability categories. Allowing users to define model assignments per capability category increases:. Allow users to define models per category, for example:. The runtime then selects an appropriate model based on user configuration. If a tool requests a capability that has not yet been mapped by the user (e.g., `"deep_reasoning_level_3"` or `"creative_uncensored_longform"`), the system should gracefully fall back to the default model. At the same time, this unresolved request should appear in the user configuration as an “unassigned capability.” The user can then choose to link that capability to an existing category, assign a specific model, or define a new routing rule.

Credential Pools - Hermes Agent

Credential pools let you register multiple API keys or OAuth tokens for the same provider. → Second 429 → rotate to next pool key. If you already have an API key set in `.env`, Hermes auto-discovers it as a 1-key pool. hermes auth add openrouter --api-key sk-or-v1-your-second-key. hermes auth add anthropic --type api-key --api-key sk-ant-api03-your-second-key. For providers that support both API keys and OAuth (Anthropic, Nous, Codex), the add flow asks which type:. | `hermes auth list` | Show all pools and credentials |. | `hermes auth add <provider>` | Add a credential (prompts for type and key) |. | `hermes auth add <provider> --type api-key --api-key <key>` | Add an API key non-interactively |. | `hermes auth add <provider> --type oauth` | Add an OAuth credential via browser login |. `hermes auth add <provider> --type api-key --api-key <key>`. `hermes auth add <provider> --type oauth`. hermes auth add Together.ai --api-key sk-together-second-key`. Pool state is stored in `~/.hermes/auth.json` under the `credential_pool` key:.

Configuration | Hermes Agent - nous research

~/.hermes/~/.hermes/├── config.yaml     # Settings (model, terminal, TTS, compression, etc.)├── config.yaml     # Settings (model, terminal, TTS, compression, etc.)├── .env            # API keys and secrets├── .env            # API keys and secrets├── auth.json       # OAuth provider credentials (Nous Portal, etc.)├── auth.json       # OAuth provider credentials (Nous Portal, etc.)├── SOUL.md         # Optional: global persona (agent embodies this personality)├── SOUL.md         # Optional: global persona (agent embodies this personality)├── memories/       # Persistent memory (MEMORY.md, USER.md)├── memories/       # Persistent memory (MEMORY.md, USER.md)├── skills/         # Agent-created skills (managed via skill_manage tool)├── skills/         # Agent-created skills (managed via skill_manage tool)├── cron/           # Scheduled jobs├── cron/           # Scheduled jobs├── sessions/       # Gateway sessions├── sessions/       # Gateway sessions└── logs/           # Logs (errors.log, gateway.log — secrets auto-redacted)└── logs/           # Logs (errors.log, gateway.log — secrets auto-redacted). # Kimi / Moonshot AI hermes chat --provider kimi-coding --model moonshot-v1-auto hermes chat --provider kimi-coding --model moonshot-v1-auto# Requires: KIMI_API_KEY in ~/.hermes/.env. # Configure Hermes OPENAI_BASE_URL=http://localhost:8402/v1 OPENAI_BASE_URL =http://localhost:8402/v1OPENAI_API_KEY=dummy OPENAI_API_KEY = dummyLLM_MODEL=blockrun/auto     # or: blockrun/eco, blockrun/premium, blockrun/agentic LLM_MODEL =blockrun/auto.

Provider Runtime Resolution

# Provider Runtime Resolution. Hermes has a shared provider runtime resolver used across:. At a high level, provider resolution uses:. That ordering matters because Hermes treats the saved model/provider choice as the source of truth for normal runs. This resolver is the main reason Hermes can share auth/runtime logic between:. Set `AI_GATEWAY_API_KEY` in `~/.hermes/.env` and run with `--provider ai-gateway`. Hermes fetches available models from the gateway's `/models` endpoint, filtering to language models with tool-use support. When provider resolution selects `anthropic`, Hermes uses:. can use their own provider/model routing rather than the main conversational model. When an auxiliary task is configured with provider `main`, Hermes resolves that through the same shared runtime path as normal chat. Hermes supports a configured fallback model/provider pair, allowing runtime failover when the primary model encounters errors. See `tests/test_fallback_model.py` for comprehensive tests covering all supported providers, one-shot semantics, and edge cases.

Full Setup with Ollama, GLM, MiniMax, Qwen

Hermes Agent just shipped multi-agent profiles. One machine, three completely independent agents, three different model backends — all running


Output:
usage: hermes [-h] [--version] [--resume SESSION] [--continue [SESSION_NAME]]
              [--worktree] [--skills SKILLS] [--yolo] [--pass-session-id]
              {chat,model,gateway,setup,whatsapp,login,logout,auth,status,cron,webhook,doctor,config,pairing,skills,plugins,honcho,tools,mcp,sessions,insights,claw,version,update,uninstall,acp,profile,completion}
              ...

Hermes Agent - AI assistant with tool-calling capabilities

positional arguments:
  {chat,model,gateway,setup,whatsapp,login,logout,auth,status,cron,webhook,doctor,config,pairing,skills,plugins,honcho,tools,mcp,sessions,insights,claw,version,update,uninstall,acp,profile,completion}
                        Command to run
    chat                Interactive chat with the agent
    model               Select default model and provider
    gateway             Messaging gateway management
    setup               Interactive setup wizard
    whatsapp            Set up WhatsApp integration
    login               Authenticate with an inference provider
    logout              Clear authentication for an inference provider
    auth                Manage pooled provider credentials
    status              Show status of all components
    cron                Cron job management
    webhook             Manage dynamic webhook subscriptions
    doctor              Check configuration and dependencies
    config              View and edit configuration
    pairing             Manage DM pairing codes for user authorization
    skills              Search, install, configure, and manage skills
    plugins             Manage plugins — install, update, remove, list
    honcho              Manage Honcho AI memory integration
    tools               Configure which tools are enabled per platform
    mcp                 Manage MCP servers and run Hermes as an MCP server
    sessions            Manage session history (list, rename, export, prune,
                        delete)
    insights            Show usage insights and analytics
    claw                OpenClaw migration tools
    version             Show version information
    update              Update Hermes Agent to the latest version
    uninstall           Uninstall Hermes Agent
    acp                 Run Hermes Agent as an ACP (Agent Client Protocol)
                        server
    profile             Manage profiles — multiple isolated Hermes instances
    completion          Print shell completion script (bash or zsh)

options:
  -h, --help            show this help message and exit
  --version, -V         Show version and exit
  --resume SESSION, -r SESSION
                        Resume a previous session by ID or title
  --continue [SESSION_NAME], -c [SESSION_NAME]
                        Resume a session by name, or the most recent if no
                        name given
  --worktree, -w        Run in an isolated git worktree (for parallel agents)
  --skills SKILLS, -s SKILLS
                        Preload one or more skills for the session (repeat
                        flag or comma-separate)
  --yolo                Bypass all dangerous command approval prompts (use at
                        your own risk)
  --pass-session-id     Include the session ID in the agent's system prompt

Examples:
    hermes                        Start interactive chat
    hermes chat -q "Hello"        Single query mode


Explanation:
¡Interesante! Veo que Hermes tiene el comando `profile` — "Manage profiles — multiple isolated Hermes instances". Eso es exactamente lo que Chicho podría querer: múltiples instancias con diferentes modelos. Voy a explorar más esto.

También vi en los resultados:
1. Credential pools - múltiples API keys del mismo provider (para rotation en rate limits)
2. smart_model_routing - cheap/strong routing
3. El video de YouTube mencionaba "multi-agent profiles" con "One machine, three completely independent agents, three different model backends"

4. Ahora voy a revisar la ayuda del comando `hermes profile` para entender exactamente cómo configurar estas instancias aisladas.


Output:
usage: hermes profile [-h]
                      {list,use,create,delete,show,alias,rename,export,import}
                      ...

positional arguments:
  {list,use,create,delete,show,alias,rename,export,import}
    list                List all profiles
    use                 Set sticky default profile
    create              Create a new profile
    delete              Delete a profile
    show                Show profile details
    alias               Manage wrapper scripts
    rename              Rename a profile
    export              Export a profile to archive
    import              Import a profile from archive

options:
  -h, --help            show this help message and exit


# Hermes Agent Configuration Guide

Hermes Agent stores all settings in the `~/.hermes/` directory. It uses a hierarchical configuration system that prioritizes CLI arguments over local files.

## 📂 Directory Structure
*   `config.yaml`: Primary settings (model, terminal, TTS, compression).
*   `.env`: API keys and secrets (automatically redacted in logs).
*   `auth.json`: OAuth credentials (Nous Portal, etc.).
*   `SOUL.md`: Optional global persona for the agent.
*   `memories/`: Persistent memory storage (`MEMORY.md`, `USER.md`).
*   `skills/`: Agent-created skills managed via `skill_manage`.
*   `sessions/` & `logs/`: Gateway sessions and error/gateway logs.

## 🛠 Configuration Management
Use the following commands to manage settings:
*   `hermes config`: View current configuration.
*   `hermes config edit`: Open `config.yaml` in your default editor.
*   `hermes config set KEY VAL`: Sets a value. **Note:** API keys are automatically routed to `.env`, while other settings go to `config.yaml`.
*   `hermes config migrate`: Interactively add missing options after an update.

### Configuration Precedence (Highest to Lowest)
1.  **CLI Arguments** (e.g., `hermes chat --model ...`)
2.  **`~/.hermes/config.yaml`** (Non-secret settings)
3.  **`~/.hermes/.env`** (Secrets and fallback env vars)
4.  **Built-in Defaults**

---

## 🤖 Inference Providers
Hermes supports a wide array of LLM providers. Use `hermes model` to switch interactively.

| Provider | Setup Requirement |
| :--- | :--- |
| **Nous Portal** | `hermes model` (OAuth/Subscription) |
| **OpenAI Codex** | Device code auth; stored in `~/.codex/auth.json` |
| **OpenRouter** | `OPENROUTER_API_KEY` in `.env` |
| **Chinese Providers** | `zai` (GLM), `kimi-coding`, `minimax`, `minimax-cn` (Requires specific API keys) |
| **Custom/Local** | Any OpenAI-compatible endpoint via `OPENAI_BASE_URL` |

### Custom & Self-Hosted Setup
Hermes works with any API implementing `/v1/chat/completions`.
*   **Ollama:** Set `OPENAI_BASE_URL=http://localhost:11434/v1`.
*   **vLLM / SGLang:** High-performance GPU serving (usually port 8000).
*   **llama.cpp:** Best for Mac/CPU/Edge deployment (usually port 8080).
*   **LiteLLM Proxy:** Use as a gateway to unify 100+ providers.
*   **ClawRouter:** Local proxy for cost-optimized routing via USDC payments.

---

## 🔍 Auxiliary & Specialized Models
Hermes uses "Auxiliary" models for side tasks (vision, summarization) to save costs on the main model. By default, it uses **Gemini Flash** via OpenRouter.

### Vision & Web Extraction
You can override these in `config.yaml`:
```yaml
auxiliary:
  vision:
    provider: "openrouter" # or "nous", "codex", "main"
    model: "openai/gpt-4o"
  web_extract:
    model: "google/gemini-2.5-flash"
```

### Context Compression
When conversations get long, Hermes compresses context:
*   **Threshold:** Default `0.85` (85% of context limit).
*   **Summary Model:** Must support a context length equal to or greater than the main model.

---

## ⚙ Advanced Feature Settings

### Terminal & Code Execution
*   **Backends:** `local`, `docker`, `ssh`, `singularity`, `modal`, `daytona`.
*   **Code Sandbox:** Python execution is limited by `timeout` (default 300s) and `max_tool_calls` (default 50).

### Git Worktree Isolation
Enable with `worktree: true` in `config.yaml` or `hermes -w`.
*   Creates isolated environments in `.worktrees/`.
*   Allows multiple agents to work on the same repo in parallel without file conflicts.
*   Use `.worktreeinclude` to specify gitignored files (like `.env`) that should be copied to the worktree.

### Memory & Reasoning
*   **Memory Limits:** `memory_char_limit` (default 2200) and `user_char_limit` (default 1375).
*   **Reasoning Effort:** Options include `xhigh`, `high`, `medium`, `low`, `minimal`, `none`. Default is `medium`.

### Optional Integrations
*   **Web Scraping:** `FIRECRAWL_API_KEY` (Cloud) or set `FIRECRAWL_API_URL` for self-hosted Docker instances.
*   **Browser Automation:** `BROWSERBASE_API_KEY`.
*   **Image Gen:** `FAL_KEY`.
*   **TTS:** Supports `edge` (free, 322 voices), `elevenlabs` (premium), and `openai`.

---

## 📝 Context Files
Hermes automatically detects specific files in your project directory to guide its behavior:
*   **`AGENTS.md`**: Project-specific instructions and coding standards.
*   **`SOUL.md`**: Defines the agent's personality.
*   **`.cursorrules` / `.mdc`**: Compatibility with Cursor IDE rules.
*   **Note:** These files are capped at 20,000 characters with smart truncation.


Output:
Profile          Model                        Gateway      Alias
 ───────────────    ───────────────────────────    ───────────    ────────────
 ◆default         claude-sonnet-4-6            running      —


Sí, hay varias formas de hacerlo. Te explico las opciones:

**OPCIÓN 1: PROFILES (la más potente)**
Hermes tiene `hermes profile` — podés crear instancias completamente aisladas, cada una con su propio modelo, config, memoria, skills. Ahora mismo solo tenés `default` con `claude-sonnet-4-6`. Podrías crear:

- `pipo-opus` → claude-opus-4-6 (yo, para tasks complejas)
- `pipo-gemini` → gemini-2.5-pro (contexto largo, multimodal)
- `pipo-gpt5` → gpt-5 (all-rounder barato)

Cada uno corre con su propio gateway, separado.

**OPCIÓN 2: SMART MODEL ROUTING (dentro de una sola sesión)**
Un solo "Pipo" que ruteea automático: mensajes simples van a Gemini Flash (barato), los complejos se quedan con el modelo principal. Está listo en el config, solo hay que activarlo.

**OPCIÓN 3: FALLBACK MODEL**
Si el modelo principal se cae o da rate limit, automáticamente tira al siguiente. Está comentado en el config, listo para activar.

---

¿Qué tenés en mente exactamente? ¿Querés varios "Pipos" especializados con diferentes personalidades/modelos, o querés un solo Pipo que use varios modelos según la tarea?

Explanation:
Ahora entiendo bien el sistema. Hermes tiene:

1. **Profiles** - múltiples instancias aisladas con diferentes configs/modelos. Esto es exactamente lo que Chicho quiere - puede tener un "Pipo" con Claude, otro con Gemini, otro con GPT-5, etc.

2. **smart_model_routing** - dentro de un perfil, puede rutear mensajes simples a un modelo barato y complejos al principal

3. **Credential pools** - múltiples API keys del mismo provider para rotación en rate limits

4. **Fallback model** - cuando el principal falla, cambia automáticamente al modelo de respaldo

Cuando Chicho menciona "varios amigos", probablemente se refiere a que tiene acceso a múltiples proveedores o modelos. Con `hermes profile create` puede crear un perfil independiente para cada uno, y luego explicaré cómo usar profiles para instancias aisladas o smart_model_routing si quiere ruteo automático dentro de una misma sesión.


lo que no entiendo de la opcion 1, que me gusta al ser la mas potente, es como es que cada uno corre con su propio gateway? al final tipo trabajan juntos o nah


Explanation: Chicho pregunta cómo funciona el sistema de profiles con gateways separados - si trabajan juntos o son instancias completamente independientes. Voy a buscar más info sobre esto en la documentación de Hermes.


Question: hermes agent profiles multiple instances gateway isolated site:hermes-agent.nousresearch.com

terminal

hermes profile create --help 2>&1 && hermes gateway --help 2>&1


Security | Hermes Agent - Nous Research

This page covers every security boundary — from command approval to container isolation to user authorization on messaging platforms. Before executing any command, Hermes checks it against a curated list of dangerous patterns. | **manual** (default) | Always prompt the user for approval on dangerous commands |. Internally, it sets the `HERMES_YOLO_MODE` environment variable which is checked before every command execution. **Container bypass**: When running in `docker`, `singularity`, `modal`, or `daytona` backends, dangerous command checks are **skipped** because the container itself is the security boundary. Commands approved with "always" are saved to `~/.hermes/config.yaml`:. Set GATEWAY_ALLOW_ALL_USERS=true in ~/.hermes/.env to allow open access,. | **execute\_code** | Blocks vars containing `KEY`, `TOKEN`, `SECRET`, `PASSWORD`, `CREDENTIAL`, `PASSWD`, `AUTH` in name; only allows safe-prefix vars through | ✅ Passthrough vars bypass both checks |. | **terminal** (local) | Blocks explicit Hermes infrastructure vars (provider keys, gateway tokens, tool API keys) | ✅ Passthrough vars bypass the blocklist |.

Profiles: Running Multiple Agents | Hermes Agent - nous research

`hermes profile create coder # creates profile + "coder" command alias. `hermes profile create work --clone`. `~/.hermes/profiles/work/SOUL.md`. `hermes profile create backup --clone-all`. `hermes profile create work --clone --clone-from coder`. ### Sticky default (`hermes profile use`). hermes profile use default # switch back`. nano ~/.hermes/profiles/coder/.env. nano ~/.hermes/profiles/assistant/.env`. echo "You are a focused coding assistant." > ~/.hermes/profiles/coder/SOUL.md`. hermes profile show coder # detailed info for one profile. hermes profile rename coder dev-bot # rename (updates alias + service). hermes profile export coder # export to coder.tar.gz. hermes profile import coder.tar.gz # import from archive`. Use `--yes` to skip confirmation: `hermes profile delete coder --yes`. `hermes profile delete coder --yes`. You cannot delete the default profile (`~/.hermes`). When you run `coder chat`, the wrapper script sets `HERMES_HOME=~/.hermes/profiles/coder` before launching hermes. Since 119+ files in the codebase resolve paths via `get_hermes_home()`, everything automatically scopes to the profile's directory — config, sessions, memory, skills, state database, gateway PID, logs, and cron jobs.

FAQ & Troubleshooting | Hermes Agent

### What LLM providers work with Hermes?. Hermes Agent works with any OpenAI-compatible API. On Windows, install WSL2 and run Hermes from inside it. Yes. Point Hermes at any local OpenAI-compatible server:. hermes config set OPENAI_API_KEY ollama # Any non-empty value. hermes config set HERMES_MODEL llama3.1`. Yes. The messaging gateway lets multiple users interact with the same Hermes Agent instance via Telegram, Discord, Slack, WhatsApp, or Home Assistant. agent = AIAgent(model="openrouter/nous/hermes-3-llama-3.1-70b"). **Cause:** Hermes requires Python 3.11 or newer. hermes config set OPENROUTER_API_KEY sk-or-v1-xxxxxxxxxxxx`. hermes config set HERMES_MODEL openrouter/nous/hermes-3-llama-3.1-70b. **Cause:** The messaging gateway runs without an interactive terminal, so `sudo` cannot prompt for a password. Configure in `~/.hermes/config.yaml` under your gateway's settings. pip install hermes-agent[telegram] # or [discord], [slack], [whatsapp]. **Cause:** Large model, distant API server, or heavy system prompt with many tools. pip install hermes-agent[mcp]. Verify your `~/.hermes/config.yaml` MCP configuration:. hermes config show | grep -A 5 mcp_servers. Check the server's own logs (not just Hermes logs) to diagnose the root cause.

Discord - Hermes Agent

Hermes Agent integrates with Discord as a bot, letting you chat with your AI assistant through direct messages or server channels. If you want a normal bot-help channel where people can talk to Hermes without tagging it every time, add that channel to `DISCORD_FREE_RESPONSE_CHANNELS`. This guide walks you through the full setup process — from creating your bot on Discord's Developer Portal to sending your first message. Without the correct intents enabled, your bot will connect to Discord but **will not be able to read message content**. Hermes Agent uses your Discord User ID to control who can interact with the bot. **Fix**: Enable all three Privileged Gateway Intents (Presence, Server Members, Message Content) in the Bot settings, then restart. **Fix**: In Discord, go to the channel's settings → Permissions → add the bot's role with **View Channel** and **Read Message History** enabled. **Fix**: Add your User ID to `DISCORD_ALLOWED_USERS` in `~/.hermes/.env` and restart the gateway.


Output:
usage: hermes profile create [-h] [--clone] [--clone-all]
                             [--clone-from SOURCE] [--no-alias]
                             profile_name

positional arguments:
  profile_name         Profile name (lowercase, alphanumeric)

options:
  -h, --help           show this help message and exit
  --clone              Copy config.yaml, .env, SOUL.md from active profile
  --clone-all          Full copy of active profile (all state)
  --clone-from SOURCE  Source profile to clone from (default: active)
  --no-alias           Skip wrapper script creation
usage: hermes gateway [-h]
                      {run,start,stop,restart,status,install,uninstall,setup}
                      ...

Manage the messaging gateway (Telegram, Discord, WhatsApp)

positional arguments:
  {run,start,stop,restart,status,install,uninstall,setup}
    run                 Run gateway in foreground
    start               Start gateway service
    stop                Stop gateway service
    restart             Restart gateway service
    status              Show gateway status
    install             Install gateway as service
    uninstall           Uninstall gateway service
    setup               Configure messaging platforms

options:
  -h, --help            show this help message and exit