Haystack 3.0 Launch Week

Day 01 · Mon, Jul 20 Live

Haystack 3.0

Haystack 3.0 is the release where agents move to the center of the framework.

Pre-configured agents with memory, tools, and skills out of the box
Hooks, first-class skills, and dynamic tool selection for the Agent component
Migration guide + skill to move from 2.x to 3.0

Read the release announcement

terminal

pip install --upgrade haystack-ai

# Load the skill
# Start your favorite coding agent 

/haystack-v2-to-v3 Migrate Haystack code to v3

Day 02 · Tue, Jul 21 Live

Give Your Agent a Budget

Turn Agent metadata into an actual budget policy, and enforce it live with hooks so an over-budget run stops before the next LLM call fire.

Built-in metadata: read step_count, token_usage, and tool_call_counts off any agent run
Agent hooks: take actions before_llm, before_tool, or after_run
Budget policies: implement soft and hard token limits with allow, warn, or block agent actions

Cost-Aware Agent with Hooks Watch the video

cost_aware_agent.py

from haystack.components.agents import Agent
from haystack.components.agents.state import State
from haystack.hooks import hook

@hook
def enforce_budget_before_llm(state: State) -> None:
    decision = evaluate_agent_budget(state.data, policy)
    if decision["action"] == "block":
        raise RuntimeError("Hard budget exceeded")

agent = Agent(
    chat_generator=OpenAIChatGenerator(model="gpt-4o-mini"),
    tools=[price_lookup],
    hooks={"before_llm": [enforce_budget_before_llm]},
)

result = agent.run(messages=[ChatMessage.from_user(
    "Compare prices for laptop, keyboard, and monitor."
)])

Day 03 · Wed, Jul 22 Live

Agent Pack

Agent Pack ships pre-built, complex agents that bake in agent-building best practices, ready to run out of the box and fully configurable when you need to go deeper.

Deep Research Agent: a multi-agent system built around context engineering for deep research topic
Advanced RAG Agent: a metadata-aware RAG agent that constructs its own filters to narrow retrieval
One line or a blueprint: packaged behind a single create_* call, but the source code is public Haystack primitives you can copy and adapt
Fully tunable: swap models per step, cap steps and concurrency

Using Pre-Built Agents from Agent Pack

deep_research_agent.py

# pip install agent-pack-haystack 

from haystack.dataclasses import ChatMessage
from haystack_integrations.agent_pack import (
    create_deep_research_agent,
)

research_agent = create_deep_research_agent(
    max_subtopics=2,
    max_concurrent_researchers=2,
    max_researcher_steps=6,
    max_search_results=5,
)

result = research_agent.run(
    messages=[ChatMessage.from_user(
        "What are the main techniques for managing "
        "the context window in LLM agents?"
    )]
)
print(result["report"])

Day 04 · Thu, Jul 23 Live

Let Your Agent Use a Computer

A fully local agent running on Ollama that reads skills, saves tokens, and uses a real bash tool to control your machine, with a human approving every step

Use Skills: a SkillToolset gives the agent read-only instructions it can load on demand
Progressive disclosure keeps context small: the agent only sees skill names + one-line descriptions until it decides one applies
Real computer use: a custom async bash tool lets the agent inspect the actual machine (OS info, disk space, files)
Human-in-the-loop with hooks: a ConfirmationHook pauses before bash call so no sensitive action runs without an approval

Computer-Use Agent with Skills Watch the video

computer_use_agent.py

from haystack.components.agents import Agent
from haystack.skill_stores.file_system import FileSystemSkillStore
from haystack.tools import SkillToolset

bash_tool_confirmation_hook = ConfirmationHook(
    confirmation_strategies={
        "bash": BlockingConfirmationStrategy(
            AlwaysAskPolicy(), SimpleConsoleUI()
        )
    }
)

agent = Agent(
    chat_generator=chat_generator,
    tools=[bash, SkillToolset(FileSystemSkillStore("skills/"))],
    hooks={"before_tool": [bash_tool_confirmation_hook]},
)

result = await agent.run_async(messages=[
    ChatMessage.from_user(
        "Check disk space and largest files. "
        "Make this as token-efficient as possible."
    )
])

Day 05 · Fri, Jul 24 Live

Human-in-the-Loop from Terminal to Prod

A Haystack Agent that pauses before sensitive actions and waits for a person to approve them, right inside a real chat UI, deployed with Hayhooks

Asks before it acts: for any high-stakes tool call, the agent stops and waits for a person to approve or reject it before going ahead
Approve it right in the chat: Open WebUI shows the confirmation pop-up, so saying yes or no feels like part of the conversation
Runs as a real service: the agent is served through Hayhooks as an OpenAI-compatible endpoint, so any chat UI can talk to it
One command to run it all: a docker-compose file spins up the agent, the UI, and everything in between

GitHub Repo Watch the video

hitl_hayhooks.py

# Served via Hayhooks + Open WebUI + Redis:
# docker compose up -d --build

from haystack.components.agents import Agent
from haystack.hooks.human_in_the_loop import ConfirmationHook

# Only the risky tool pauses for approval —
confirmation_hook = ConfirmationHook(
    confirmation_strategies={
        "submit_feedback_to_deepset": RedisConfirmationStrategy(),
    }
)

agent = Agent(
    chat_generator=OpenAIChatGenerator(model="gpt-4o-mini"),
    tools=[whats_new_today, search_docs, submit_feedback],
    hooks={"before_tool": [confirmation_hook]},
)