Hooks

[ottosulin]

Component

CLI

Problem statement

I would want to run pre-defined shell commands based on events in Vibe, like Claude Code Hooks.

Use cases would be for example trigger run of a linter or adding extra guardrail pre/post tool call.

Proposed solution

Allow users to specify in the configuration a shell command to run after or before certain events in Vibe CLI.

Additional context

No response

[tgourdel]

+1, forcing the use of specific commands instead of others seem like a common use case for hooks.

[smheidrich]

More generally, any time the model tries to do something stupid (whether it be running a certain command or trying to add a certain piece of code), it would be great if we could catch it with a hook and tell it to do something else.

In an ideal world, putting sufficient instructions into AGENTS.md or the global system prompt should prevent such issues, but in reality the model often forgets or ignores them, so hooks would be a nice way to inject reminders at just the right moments so they're less likely to be ignored.

[LoicBovo]

+1 to me it also can help with security to make sure the agent is not performing certain tasks like git push for instance.

[raine]

Hooks support would be useful for tools that manage multiple agent sessions. I maintain a tmux-based workspace manager for AI coding agents. It uses hooks to track agent status and display it in the tmux window list, so you can see which agents are working, waiting for input, or done.

Without hooks, there's no reliable way to know what state the agent is in from the outside.

A minimal set of lifecycle hooks would be enough for this use case:

• Agent started / stopped
• Waiting for user input (permissions etc.)

[smheidrich]

If you check the release notes for 2.9.0, it contains

• Experimental hooks system with post-agent-turn lifecycle

🥳

How to use this doesn't seem to be documented anywhere yet, but Vibe itself managed to generate a decent summary, which seems accurate after testing it myself:

How to use experimental hooks (❌ Outdated as of 2.15.0, cf. comment below!)

⚠️ LLM-generated

Prerequisites:

1. Enable experimental hooks in config.toml:

   enable_experimental_hooks = true

   OR via environment variable:

   export VIBE_ENABLE_EXPERIMENTAL_HOOKS=true

2. Create a hooks.toml file in either:

   • ~/.vibe/hooks.toml (user-level)
   • <project>/.vibe/hooks.toml (project-level, requires trusted folder)

Configuration Format:

[[hooks]]
name = "lint"                     # Unique hook name (required)
type = "post_agent_turn"          # Hook type (required, currently only option)
command = "eslint --quiet ."      # Shell command to execute (required)
timeout = 30.0                    # Seconds before timeout (default: 30)
description = "Run ESLint"        # Optional description

Currently Available Hook Types:

• post_agent_turn - Runs after the agent finishes a turn (no more pending tool calls)

How Hooks Execute:

• Each hook runs as a shell subprocess in the current working directory
• Receives JSON on stdin with context:

  {
    "session_id": "...",
    "transcript_path": "/path/to/session/log.jsonl",
    "cwd": "/current/working/dir",
    "hook_event_name": "post_agent_turn"
  }

Exit Code Semantics:

• 0 - Success (hook output shown as info message)
  • Note: In my testing, I didn't actually see the output shown as info messages. Might be a wrong conclusion by the LLM or perhaps I did something wrong. In any case, the LLM doesn't see it either.
• 2 - Retry (hook's stdout injected as new user (!) message, agent gets another turn to fix issues, max 3 retries)
• Any other - Warning (hook output shown as warning message to the user, but hidden from the LLM)

Retry Mechanism:
The exit code 2 is powerful: it allows hooks to provide feedback that gets fed back to the agent. For example, a linter hook can output errors and exit with code 2, causing the agent to try to fix them automatically.

My conclusions after playing around with this:

• This post-agent-turn hook is useful for enforcing running of linters and so on that the LLM might forget to invoke otherwise when it considers itself done.
• But I wish there was also a "post-tool-call" hook, e.g. to give advice to the LLM when it's trying to run commands that can't possibly work, before that makes it spiral into trying more and more desperate and increasingly stupid workarounds. The post-agent-turn hook doesn't help with that, because all these desperate attempts happen within the LLM's turn, so by the time the hook gets called, it's already too late.
  • Update: This was introduced in 2.15.0, cf. comment below!

[smheidrich]

2.15.0 introduced some breaking changes to hooks that make the above instructions incorrect, along with new features.¹ Hooks are now also documented in the README as well as in Vibe's built-in "self-knowledge" skill. I'll mark the above instructions as outdated to avoid confusion.

^{1 In particular pre- and post-tool-call hooks, just what I wanted - thanks! 🙂}

[tale80]

+1, and JetBrains Rider now support hooks to use IDE tools to help agent to provide better results (https://blog.jetbrains.com/dotnet/2026/06/08/rider-2026-2-code-quality-check-hooks-for-ai-agents/).

Can be good to have more documentation so we can configure it, and maybe ask JetBrains to add it directly like they did for claude code.