The AI Toolchain — issue -366, May 31, 2025

Agno v1.5.5 adds Claude file upload, prompt caching, Qdrant hybrid search, Markdown knowledge bases, and AI/ML API integration.

$ git clone --branch v1.5.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.5.5

agent = Agent(
    ...
    search_previous_sessions_history=True,
)

storage = RedisStorage(
    ...
    expire=3600,
)

• ›Adds search_previous_sessions_history to enable a get_previous_session_messages(number_of_sessions: int) tool that lets agents retrieve and analyse messages from the last N sessions.
• ›Adds expire key to Redis storage configuration to set TTL on Redis keys.
• ›Adds cache_creation_input_tokens to agent session metrics for tracking Anthropic prompt-cache write statistics.
• ›Supports direct file upload to Anthropic for use as agent input (Claude File Upload).
• ›Enables Python code execution in a secure, sandboxed environment via the Claude 4 Code Execution Tool.

Agno v1.5.4 adds Human-in-the-loop control flows, a Mem0 memory toolkit, and Firecrawl web search support.

$ git clone --branch v1.5.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.5.4

from agno.agent import Agent
from agno.tools.user_control_flow import UserControlFlowTools

agent = Agent(
    tools=[UserControlFlowTools(), ...],
    ...
)

• ›Adds @tool(requires_confirmation=True) decorator to pause agent runs and require explicit user confirmation before a tool executes.
• ›Adds @tool(requires_user_input=True) decorator to halt agent execution and prompt for user input before continuing.
• ›Adds @tool(external_execution=True) decorator to signal that a tool function will be executed outside the agent context.
• ›Adds UserControlFlowTools() — include it in an agent to enable dynamic, model-driven user-input pauses anywhere in a run.
• ›Adds agent.continue_run and agent.acontinue_run methods to resume a paused agent run after user control flow requirements are satisfied.

Agno v1.5.3 improves accuracy evaluation methodology for more reliable agent-based assessment.

$ git clone --branch v1.5.3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.5.3

• ›Updates the accuracy evaluation mechanism to use a more precise agent-based approach for measuring agent performance.

Agno v1.5.2 adds FastAPI/WhatsApp app wrappers, Couchbase vector DB, BigQuery tools, and async S3 readers

$ git clone --branch v1.5.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.5.2

from agno.vectordb.mongodb import MongoDBVectorDb

vector_db = MongoDBVectorDb(
    connection_string="<your-cosmos-vcore-connection-string>",
    database_name="agno_kb",
    collection_name="embeddings",
    cosmos_compatibility=True,
)

from agno.tools import Toolkit

class MyTools(Toolkit):
    def __init__(self):
        super().__init__(
            stop_after_tool_call_tools=["run_query"],
            show_result_tools=["run_query", "fetch_report"],
        )

• ›Adds FastAPIApp class — a convenience wrapper that spins up a FastAPI server exposing an agent or team with minimal boilerplate.
• ›Adds WhatsappAPIApp class — implements the WhatsApp protocol so an Agno agent can run on WhatsApp, with image/audio/video input, image response generation, and reasoning support.
• ›Adds stop_after_tool_call_tools and show_result_tools properties to the base Toolkit class, mirroring the per-tool behavior previously only available via the @tool decorator.
• ›Enables cosmos_compatibility=True on the MongoDB vector DB class to add Azure Cosmos DB for MongoDB (vCore) as a supported vector store backend.
• ›Adds Couchbase as a supported vector DB for knowledge bases.

Agno v1.5.1 adds Nebius as a model provider, extends vector DB filter support to pgvector/Milvus/Weaviate/Chroma, and adds SSL to Redis storage.

$ git clone --branch v1.5.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.5.1

from agno.storage.redis import RedisStorage

storage = RedisStorage(
    host="my-redis-host",
    port=6380,
    ssl=True
)

• ›Adds ssl parameter to the Redis storage class, enabling encrypted connections to Redis backends.
• ›Adds Nebius (Nebius Studio) as a new model provider via an OpenAI-compatible interface.
• ›Extends filtering support to additional vector databases: pgvector, Milvus, Weaviate, and Chroma.

Agno v1.5.0 adds Azure OpenAI DALL-E image generation, OpenTelemetry auto-instrumentation, Milvus hybrid search, and streamable-HTTP MCP transport.

$ git clone --branch v.1.5.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v.1.5.0

• ›Adds hybrid_search support to the Milvus vector DB integration.
• ›Adds streamable-HTTP transport support for MCP servers via MCPTools.
• ›Adds an OpenInference auto-instrumentor for Agno agents, enabling tracing to any OpenTelemetry-compatible provider (Arize, Langfuse, Langsmith).
• ›Adds Azure OpenAI image generation via DALL-E through Azure AI Foundry.
• ›Adds ability to run accuracy evaluations with pre-generated answers; agent, prompt, and expected_answer are now accepted fields on the accuracy eval class.

Agno v1.4.7 adds Azure OpenAI image generation, OpenTelemetry auto-instrumentation, Milvus hybrid search, and streamable-HTTP MCP transport.

$ git clone --branch v1.4.7 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.4.7

from agno.vectordb.milvus import Milvus

vdb = Milvus(
    collection="my_collection",
    hybrid_search=True,
)

• ›Adds hybrid_search support to the Milvus vector DB integration.
• ›Adds streamable-HTTP transport support for MCP servers via MCPTools.
• ›Adds an auto-instrumentor for Agno agents contributed to the OpenInference project, enabling tracing with any OpenTelemetry-compatible provider (Arize, Langfuse, Langsmith).
• ›Adds Azure OpenAI image generation tool backed by DALL-E via Azure AI Foundry.
• ›Extends accuracy evaluations to run against pre-generated answers across all evals classes.

Agno v1.4.6 adds Cerebras model support, Claude web search, and metadata-filtered knowledge bases with agentic filter detection.

$ git clone --branch v1.4.6 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.4.6

agent = Agent(
    knowledge=knowledge_base,
    enable_agentic_knowledge_filters=True
)
agent.run("Tell me about John Doe's performance review")

knowledge_base = PDFKnowledgeBase(path=[
    {"path": "alice_records.pdf", "metadata": {"user_id": "alice"}},
    {"path": "bob_records.pdf",   "metadata": {"user_id": "bob"}}
])

• ›Adds knowledge_filters parameter to Agent(...) initialization and to agent.run(...) calls for explicit metadata-based document filtering in knowledge bases.
• ›Adds enable_agentic_knowledge_filters=True on Agent to let the agent automatically detect and apply knowledge filters extracted from user queries.
• ›Adds metadata parameter to PDFKnowledgeBase path entries and to knowledge_base.load_document(path=..., metadata=...) for attaching filterable metadata at ingest time.
• ›Adds current_user_id and current_session_id as default variables in session_data for tools, making user and session context available inside tool execution.
• ›Adds Cerebras as a model provider (both OpenAILike and SDK integrations).

Agno v1.4.5 adds AWS Bedrock embeddings, Gemini video generation, and a revamped Apify integration.

$ git clone --branch v1.4.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.4.5

• ›Adds AwsBedrockEmbedder class for generating embeddings via AWS Bedrock, defaulting to the cohere.embed-multilingual-v3 model.
• ›Adds video generation capabilities to GeminiTools.
• ›Revamps ApifyTools for full compatibility with Apify actors.

Agno v1.4.4 adds async retrievers, OpenAI File uploads, Gemini video URLs, and expanded Llama model capabilities.

$ git clone --branch v1.4.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.4.4

async def my_retriever(query: str, **kwargs):
    results = await async_search(query)
    return results

agent = Agent(retriever=my_retriever, ...)
await agent.arun('What does the policy say about data retention?')

from agno.models.openai import OpenAIChat
from agno.agent import Agent
from agno.media import File

agent = Agent(model=OpenAIChat(id='gpt-4o'))
agent.run('Summarize this report.', files=[File(filepath='report.pdf')])

from agno.models.google import Gemini
from agno.agent import Agent
from agno.media import Video

agent = Agent(model=Gemini(id='gemini-2.0-flash'))
agent.run('Describe what happens in this video.', videos=[Video(url='https://example.com/incident.mp4')])

• ›The retriever parameter now accepts an async function, enabling async custom retrieval with agent.arun and agent.aprint_response.
• ›Adds support for attaching File objects to prompts for agents using OpenAIChat models, including PDF and document uploads.
• ›Adds Video(url=...) input support for Gemini models.
• ›Expands Llama and LlamaOpenAI model classes with structured output and image input support.

AutoGPT Platform beta v0.6.10 adds Google Calendar integration and Llama API support.

$ git clone --branch autogpt-platform-beta-v0.6.10 https://github.com/Significant-Gravitas/AutoGPT.git
# already have the repo? check out this version:
$ git checkout autogpt-platform-beta-v0.6.10

• ›Adds initial Google Calendar integration block for use in AutoGPT platform workflows.
• ›Adds Llama API support as a new LLM provider option.
• ›Changes email notifications from an hourly to a daily schedule.

AutoGPT Platform v0.6.9 adds agent execution continuity, scheduled late-execution checks, and CAPTCHA on auth pages.

$ git clone --branch autogpt-platform-beta-v0.6.9 https://github.com/Significant-Gravitas/AutoGPT.git
# already have the repo? check out this version:
$ git checkout autogpt-platform-beta-v0.6.9

• ›Agents that were aborted or broken can now be continued rather than requiring a full retry, preserving execution state.
• ›Sub-graphs are now included in graph-level credentials support, extending credential scoping to nested graph structures.
• ›Introduces a scheduled job that performs late execution checks, with immediate alerting on job failure.
• ›Adds CAPTCHA to login, signup, and password reset pages to protect authentication flows.
• ›Requires a discriminator value on graph save, enforcing stricter graph validation at save time.

CrewAI 0.120.0 adds agent-from-repository loading, empty Task context, and direct knowledge initialization.

$ git clone --branch 0.120.0 https://github.com/crewAIInc/crewAI.git
# already have the repo? check out this version:
$ git checkout 0.120.0

• ›Supports loading an Agent directly from a repository.
• ›Enables setting an empty context for a Task.
• ›Introduces direct initialization of knowledge, bypassing knowledge_sources.

CrewAI 0.119.0 adds parent flow identification for Crew and LiteAgent and knowledge retrieval prompt rewriting in Agent.

$ git clone --branch 0.119.0 https://github.com/crewAIInc/crewAI.git
# already have the repo? check out this version:
$ git checkout 0.119.0

• ›Enables parent flow identification for Crew and LiteAgent, improving traceability in nested flow architectures.
• ›Introduces knowledge retrieval prompt rewriting in Agent for improved tracking and debugging of RAG-based workflows.

DSPy 2.6.23 adds async streaming support and token streaming with the JSON adapter.

$ git clone --branch 2.6.23 https://github.com/stanfordnlp/dspy.git
# already have the repo? check out this version:
$ git checkout 2.6.23

• ›Supports streaming in async DSPy programs, enabling real-time token delivery in async execution contexts.
• ›Supports token streaming with the JSON adapter, so structured-output pipelines can now stream tokens incrementally.
• ›Adds a utility to convert an async stream to a sync stream, bridging async streaming sources into synchronous DSPy programs.
• ›Updates MIPROv2 auto settings and general optimizer behavior.

langchain-openai 0.3.18 adds support for built-in code interpreter and remote MCP tools, plus async embedding performance improvements.

$ git clone --branch langchain-openai==0.3.18 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-openai==0.3.18

• ›Supports OpenAI built-in code interpreter and remote MCP tools as callable tool types.
• ›Runs _tokenize in a background thread during async embedding invocations, enabling non-blocking embedding calls in async contexts.
• ›Adds compatibility with Bedrock Converse for OpenAI-style LLM interactions.

LangChain Core 0.3.61 adds Union type support in strict OpenAI structured output mode and improves Runnable typing.

$ git clone --branch langchain-core==0.3.61 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-core==0.3.61

• ›Supports Union type args in strict mode of OpenAI function calling and structured output, enabling more expressive type annotations in constrained response schemas.
• ›Improves typing annotations on the Runnable __or__ method for better IDE and type-checker support when chaining runnables.
• ›Allows async indexing code to work with vectorstores that only define a synchronous delete method, broadening async compatibility.

langchain-ollama 0.3.3 adds async-client kwargs and arbitrary-role ChatMessage support for Ollama.

$ git clone --branch langchain-ollama==0.3.3 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-ollama==0.3.3

• ›Adds a separate kwargs parameter for the async Ollama client, enabling independent configuration of async vs. sync client calls.
• ›Supports passing ChatMessage objects with arbitrary roles directly to Ollama, enabling custom role definitions beyond the standard user/assistant/system set.

langchain-anthropic 0.3.13 adds web search support, URL inputs to ChatAnthropic, and kwargs pass-through for token counting

$ git clone --branch langchain-anthropic==0.3.13 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-anthropic==0.3.13

• ›Adds web search support to ChatAnthropic via Anthropic's web search tool integration.
• ›Enables ChatAnthropic to accept URLs as message content inputs.
• ›Allows kwargs to pass through when calling the token-counting method on ChatAnthropic, enabling additional parameters to reach the underlying API.
• ›Makes the description field optional on AnthropicTool, removing a previously required constraint.

langchain-huggingface 0.2 adds Inference Provider support for chat and embeddings, IPEX model acceleration, and required tool_choice for ChatHuggingFace.

$ git clone --branch langchain-huggingface==0.2.0 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-huggingface==0.2.0

from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint

llm = HuggingFaceEndpoint(repo_id="mistralai/Mistral-7B-Instruct-v0.3")
chat = ChatHuggingFace(llm=llm)
chat_with_tools = chat.bind_tools([my_tool], tool_choice="required")
response = chat_with_tools.invoke("What is the weather in Paris?")

from langchain_huggingface import HuggingFaceEndpointEmbeddings

embeddings = HuggingFaceEndpointEmbeddings(
    model="sentence-transformers/all-MiniLM-L6-v2",
    huggingfacehub_api_token="<your_token>",
)
vectors = embeddings.embed_documents(["Hello world", "LangChain rocks"])

from langchain_huggingface import HuggingFaceEmbeddings

embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2",
    model_kwargs={"backend": "ipex"},
)
vectors = embeddings.embed_documents(["Accelerated on Intel hardware"])

• ›Adds required value support for tool_choice in ChatHuggingFace, enabling strict tool-calling enforcement.
• ›Adds model alias parameter to embedding classes for consistency across LangChain embedding integrations.
• ›Integrates Hugging Face Inference Providers into ChatHuggingFace chat models, replacing deprecated code paths.
• ›Integrates Hugging Face Inference Providers into embedding classes, replacing deprecated code paths.
• ›Adds IPEX (Intel Extension for PyTorch) support to HuggingFaceEmbeddings for accelerated inference on Intel hardware.

LangChain 0.3.25 adds DB column comments retrieval, attachment returns, and removes Python version upper bound.

$ git clone --branch langchain==0.3.25 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain==0.3.25

• ›Adds get_col_comments option to the community database integration for retrieving column-level comments from database schemas.
• ›Adds explicit service_tier attribute to the OpenAI integration for controlling OpenAI service tier selection.
• ›Returns attachments in _get_response, enabling downstream access to message attachments.
• ›Removes the beta decorator from init_embeddings, marking it as stable.
• ›Removes the Python version upper bound from langchain and related libraries, allowing installation on future Python releases.

langchain-openai 0.3.15 adds explicit service_tier attribute, reasoning summary streaming, and multi-modal/PDF/audio support in OpenAI message conversion.

$ git clone --branch langchain-openai==0.3.15 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-openai==0.3.15

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="o3-mini", service_tier="flex")
response = llm.invoke("Summarize the risks in this contract.")
print(response.content)

• ›Adds explicit service_tier attribute to chat completion requests, enabling direct control over OpenAI flex vs. default processing tiers.
• ›Supports streaming of OpenAI reasoning summaries, allowing incremental consumption of chain-of-thought output in streaming workflows.
• ›Supports PDF and audio input in the Chat Completions message format via core and langchain-openai.
• ›Supports standard multi-modal blocks in convert_to_openai_messages, unifying how image, audio, and document content is serialized for the OpenAI API.
• ›Removes Python upper bound version constraint for langchain and related libraries, broadening compatibility with newer Python releases.

LangGraph prebuilt 0.2.0 adds a post_model_hook, HumanInterruptNode, parallel tool calls via Send, and a SqliteStore with namespace search.

$ git clone --branch prebuilt==0.2.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout prebuilt==0.2.0

from langgraph.prebuilt import create_react_agent

def my_post_model_hook(state):
    # inspect or mutate state after each model call
    print("Model output:", state["messages"][-1].content)
    return state

agent = create_react_agent(
    model=llm,
    tools=[...],
    post_model_hook=my_post_model_hook,
)

from langgraph.store.sqlite import SqliteStore

store = SqliteStore("agent_memory.db")

# list namespaces up to 2 levels deep
namespaces = store.list_namespaces(max_depth=2)
print(namespaces)

• ›Adds post_model_hook parameter to inject custom logic after model responses in create_react_agent.
• ›Introduces HumanInterruptNode for structured human-in-the-loop interruption handling in prebuilt agents.
• ›Switches parallel tool call execution to use Send by default, enabling concurrent tool dispatch in the ReAct agent.
• ›Releases SqliteStore as a persistent key-value store backend with namespace search and list_namespaces supporting max_depth filtering.

LangGraph SQLite checkpoint adds SqliteStore and InMemoryCache for persistent and in-memory state storage.

$ git clone --branch checkpointsqlite==2.0.8 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointsqlite==2.0.8

store = SqliteStore("./agent_state.db")
# ... populate store ...
store.clear()  # deletes all entries when called without arguments

• ›New SqliteStore provides a SQLite-backed key-value store for persisting LangGraph state across runs.
• ›New InMemoryCache (moved into the sqlite package alongside FileCache) enables fast, non-persistent caching without a database.
• ›Adds SqliteStore release as the official sqlite store integration for LangGraph checkpointing.
• ›Overloaded clear() method on the store now deletes all entries when called without arguments.

LangGraph checkpoint 2.0.26 adds InMemoryCache, namespace-scoped cache keys, TTL support, and pickle fallback for the JSON serializer.

$ git clone --branch checkpoint==2.0.26 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==2.0.26

• ›Adds InMemoryCache as a new cache backend alongside the existing file-based cache.
• ›Moves FileCache to the sqlite package and re-implements it using SQLite for more reliable storage.
• ›Adds namespace support to cache keys, enabling isolated cache spaces across different workloads.
• ›Implements TTL (time-to-live) expiry in FileCache, allowing automatic cache entry invalidation.
• ›Overloads the clear method so calling it without arguments deletes all cache entries.

LangGraph 0.4.4 adds update_state for the functional API, a caching layer with InMemoryCache, and deferred node execution.

$ git clone --branch 0.4.4 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.4.4

from langgraph.func import entrypoint, task
from langgraph.types import Command
from langgraph.checkpoint.memory import MemorySaver

checkpointer = MemorySaver()

@entrypoint(checkpointer=checkpointer)
def my_graph(state):
    return state

# Update state for a specific thread mid-run
my_graph.update_state({"configurable": {"thread_id": "thread-1"}}, {"key": "new_value"})

• ›Implements update_state for the functional API, enabling state updates mid-graph in entrypoint-based workflows.
• ›Introduces a cache interface with InMemoryCache and FileCache (moved to sqlite package), including clear methods and namespace-scoped cache keys.
• ›Adds cache_policy acceptance on graph, entrypoint, and pregel for default caching configuration.
• ›Adds support for Deferred Nodes, enabling nodes whose execution can be deferred within a graph.
• ›Adds ability to start the dev server externally.

LangGraph Python SDK adds customizable client timeouts, loop-safe ASGI transport, and a new 'running' RunStatus.

$ git clone --branch sdk==0.1.69 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.1.69

from langgraph_sdk import get_client

client = get_client(url="http://localhost:8123", timeout=30)

• ›Supports customizable timeouts in get_client() for fine-grained control over request lifecycle.
• ›Adds optional loop-safe ASGI transport to avoid event-loop conflicts in async environments.
• ›Adds missing 'running' value to RunStatus enum, enabling accurate status checks on in-progress runs.

LangGraph 0.4.3 uses tuples for streamed message events in RemoteGraph and adds a draw limit to Pregel graphs.

$ git clone --branch 0.4.3 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.4.3

• ›Uses tuples for streamed message events in RemoteGraph, aligning remote streaming with local graph conventions.
• ›Adds a node limit to Pregel.draw to prevent rendering failures on very large graphs.

LangGraph 0.4.2 decouples RemoteGraph name from assistant ID and executes parallel tool calls via Send by default.

$ git clone --branch 0.4.2 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.4.2

• ›Decouples the graph name from the assistant ID in RemoteGraph, allowing them to be set independently.
• ›Switches prebuilt parallel tool calls to execute via Send by default, enabling more controlled parallel tool dispatch.

LangGraph checkpoint-sqlite 2.0.7 adds a delete_thread method to the Checkpointer class.

$ git clone --branch checkpointsqlite==2.0.7 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointsqlite==2.0.7

checkpointer.delete_thread(thread_id)

• ›Adds delete_thread method to the Checkpointer class for removing thread state from SQLite checkpoints.

LangGraph CLI 0.2.8 adds custom base image support and configurable headers schema for Docker workflows.

$ git clone --branch cli==0.2.8 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.2.8

• ›Supports specifying a custom base image in Docker commands.
• ›Adds schema updates for configurable headers.

LlamaIndex v0.12.38 adds embeddings caching, Claude 4, OpenTelemetry observability, Azure Foundry agent, and overhauled MCP client support.

$ git clone --branch v0.12.38 https://github.com/run-llama/llama_index.git
# already have the repo? check out this version:
$ git checkout v0.12.38

from llama_index.core.agent import FunctionAgent

agent = FunctionAgent(
    tools=[...],
    llm=llm,
    allow_parallel_tool_calls=True,
)

from llama_index.core.query_engine import NLSQLTableQueryEngine

query_engine = NLSQLTableQueryEngine(
    sql_database=sql_database,
    row_retriever=row_retriever,
    col_retriever=col_retriever,
    table_retriever=table_retriever,
)

• ›Adds cols_retrievers argument to NLSQLRetriever for column-level retrieval control.
• ›Adds row, col, and table retriever arguments to NLSQLTableQueryEngine for fine-grained SQL query engine configuration.
• ›Adds allow_parallel_tool_calls configurable argument to FunctionAgent.
• ›Adds search_filters_inference_schema client support to llama-index-indices-managed-llama-cloud.
• ›Adds stream_step and astream_step support to llama-index-agent-llm-compiler.

LlamaIndex v0.12.37 adds Vectorize retriever and Desearch tool integrations, plus missing Bedrock client params.

$ git clone --branch v0.12.37 https://github.com/run-llama/llama_index.git
# already have the repo? check out this version:
$ git checkout v0.12.37

• ›Adds llama-index-retrievers-vectorize (v0.1.0) with a new Vectorize retriever integration.
• ›Adds llama-index-tools-desearch (v0.1.0) with a new Desearch tool integration.
• ›Adds missing client params for Bedrock Converse in llama-index-llms-bedrock-converse.
• ›Passes agent workflow kwargs into the start event in llama-index-core.

LlamaIndex v0.12.35 adds memory revamp, Gel storage integrations, prefill tool kwargs, Anthropic citations, and new SlideNodeParser

$ git clone --branch v0.12.35 https://github.com/run-llama/llama_index.git
# already have the repo? check out this version:
$ git checkout v0.12.35

• ›Adds prefilling partial tool kwargs support on FunctionTool, allowing callers to pre-bind arguments before the model completes the call.
• ›Adds indexed metadata fields to llama-index-vector-stores-postgres for faster filtered queries against document metadata.
• ›Adds FaissMapVectorStore to llama-index-vector-stores-faiss, providing a map-backed Faiss vector store variant.
• ›Introduces a memory revamp in llama-index-core with a new base class and prebuilt memory blocks for agent memory management.
• ›Adds four new Gel integrations at version 0.1.0: llama-index-storage-chat-store-gel, llama-index-storage-docstore-gel, llama-index-storage-kvstore-gel, and llama-index-storage-index-store-gel.

AutoGen v0.5.6 adds GraphFlow for directed-graph agent workflows, Bing grounding citations, and Bedrock/Anthropic support.

$ git clone --branch python-v0.5.6 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.5.6

from autogen_agentchat.teams import DiGraphBuilder, GraphFlow

builder = DiGraphBuilder()
builder.add_node(writer).add_node(editor1).add_node(editor2).add_node(final_reviewer)
builder.add_edge(writer, editor1)
builder.add_edge(writer, editor2)
builder.add_edge(editor1, final_reviewer)
builder.add_edge(editor2, final_reviewer)
graph = builder.build()

flow = GraphFlow(
    participants=builder.get_participants(),
    graph=graph,
)
await Console(flow.run_stream(task="Write a short biography of Steve Jobs."))

• ›Adds GraphFlow team class and DiGraphBuilder to AgentChat, enabling directed-graph agent workflows including fan-out, fan-in, and concurrent agent execution.
• ›Adds Bing grounding citation URL support to the Azure AI Agent integration.
• ›Adds Amazon Bedrock chat completion support for Anthropic models via a new provider in autogen_ext.

OpenAI Agents SDK v0.0.15 adds Streamable HTTP transport for MCP servers and extra_body pass-through to LiteLLM.

$ git clone --branch v0.0.15 https://github.com/openai/openai-agents-python.git
# already have the repo? check out this version:
$ git checkout v0.0.15

• ›Passes extra_body through to LiteLLM acompletion calls, enabling custom request body fields when using LiteLLM as a model provider.
• ›Adds Streamable HTTP transport support for MCP servers, enabling agents to connect to MCP servers over streamable HTTP in addition to existing transports.

PydanticAI v0.2.10 adds Claude Sonnet 4 support, MCP Streamable HTTP transport, and MCP client init timeouts.

$ git clone --branch v0.2.10 https://github.com/pydantic/pydantic-ai.git
# already have the repo? check out this version:
$ git checkout v0.2.10

• ›Adds support for Claude Sonnet 4 as a model target.
• ›Adds MCP Streamable HTTP transport support, enabling HTTP-based MCP server connections alongside the existing stdio transport.
• ›Adds a timeout for initializing MCP clients, preventing indefinite hangs during MCP server startup.
• ›Updates supported Google models.

PydanticAI v0.2.9 adds Vertex AI label support for Gemini/Google models and improves Agent CLI output handling.

$ git clone --branch v0.2.9 https://github.com/pydantic/pydantic-ai.git
# already have the repo? check out this version:
$ git checkout v0.2.9

• ›Supports labels field for GeminiModel and GoogleModel on Vertex AI, enabling resource labeling for cost attribution and organization.
• ›Non-textual responses in Agent.to_cli are now cast to str, allowing the CLI interface to handle structured or binary model outputs.

PydanticAI v0.2.7 adds MCP tool_prefix namespacing, real-time Anthropic streaming, and a customizable prog_name for CLI agents.

$ git clone --branch v0.2.7 https://github.com/pydantic/pydantic-ai.git
# already have the repo? check out this version:
$ git checkout v0.2.7

from pydantic_ai.mcp import MCPServerStdio

search_server = MCPServerStdio('npx', ['-y', '@modelcontextprotocol/server-brave-search'], tool_prefix='search')
fs_server     = MCPServerStdio('npx', ['-y', '@modelcontextprotocol/server-filesystem', '/tmp'], tool_prefix='fs')
# Tools are now exposed as 'search_<name>' and 'fs_<name>', and duplicate bare names raise an error.

• ›Adds tool_prefix option to MCP servers to namespace tool names and raises an error on conflicting tool names across servers.
• ›Makes prog_name customizable on CLI agents, allowing teams to brand or script against a consistent program name.
• ›Removes the hardcoded n parameter from OpenAIModel requests, unlocking use of endpoints and deployments that reject that field.
• ›Streams tool calls and structured output from Anthropic incrementally as tokens arrive instead of buffering the full response.
• ›Supports streaming tool calls from models that pass args as None when a function has no parameters.

PydanticAI v0.2.6 adds prepare_tools param to Agent and 'openrouter' as a supported OpenAIModel provider.

$ git clone --branch v0.2.6 https://github.com/pydantic/pydantic-ai.git
# already have the repo? check out this version:
$ git checkout v0.2.6

from pydantic_ai.models.openai import OpenAIModel

model = OpenAIModel('openai/gpt-4o', provider='openrouter')

• ›Adds prepare_tools parameter to the Agent class, enabling dynamic control over which tools are presented to the model at runtime.
• ›Supports 'openrouter' as a valid string value for the provider parameter of OpenAIModel, enabling routing through OpenRouter.

PydanticAI v0.2.5 adds OpenRouter and Google GenAI providers, logprobs support, and new instrumentation controls.

$ git clone --branch v0.2.5 https://github.com/pydantic/pydantic-ai.git
# already have the repo? check out this version:
$ git checkout v0.2.5

from pydantic_ai.settings import InstrumentationSettings

settings = InstrumentationSettings(include_binary_content=False)

• ›Adds include_binary_content flag to InstrumentationSettings to control whether binary content is captured in traces; renames the OTel attribute key from content to binary_content for BinaryParts.
• ›Adds logprobs to OpenAI model settings and response objects, exposing token-level log probability data.
• ›Adds vendor_id field to model response objects.
• ›Adds ability to specify the evaluation name for all built-in Evaluators.
• ›Adds OpenRouter provider for routing requests across LLM backends.

PydanticAI v0.2.3 adds an A2A server, a direct public API, and model-settings support for LLMJudge.

$ git clone --branch v0.2.3 https://github.com/pydantic/pydantic-ai.git
# already have the repo? check out this version:
$ git checkout v0.2.3

• ›Adds direct public API for invoking models directly.
• ›Adds an A2A (Agent-to-Agent) server, enabling agents to communicate via the A2A protocol.
• ›Allows ModelSettings to be defined on LLMJudge to control model behavior during evaluations.

PydanticAI v0.2.2 adds a to_cli() method to Agent for instant command-line interfaces.

$ git clone --branch v0.2.2 https://github.com/pydantic/pydantic-ai.git
# already have the repo? check out this version:
$ git checkout v0.2.2

agent = Agent(model='openai:gpt-4o', system_prompt='You are a helpful assistant.')
if __name__ == '__main__':
    agent.to_cli()

• ›Adds to_cli() method to the Agent class, enabling any agent to be exposed as a CLI application.

PydanticAI v0.2.1 adds AWS Profile support, CLI config persistence, and OpenTelemetry BinaryContent tracing.

$ git clone --branch v0.2.1 https://github.com/pydantic/pydantic-ai.git
# already have the repo? check out this version:
$ git checkout v0.2.1

• ›CLI now stores prompt history and configuration under ~/.pydantic-ai for persistence across sessions.
• ›OpenTelemetry integration now sends BinaryContent information in traces.
• ›Adds AWS Profile support for authenticating with AWS-backed models.
• ›Improves Agent.is_*_node() type narrowing by switching to TypeIs for more precise static analysis.

PydanticAI v0.2.0 moves usage data into ModelResponse and adds non-string enum support for Gemini.

$ git clone --branch v0.2.0 https://github.com/pydantic/pydantic-ai.git
# already have the repo? check out this version:
$ git checkout v0.2.0

response = await model.request(messages, model_request_parameters)
print(response.usage)

• ›Adds usage field to ModelResponse (defaults to Usage() for backward-compatible deserialization), making token/cost usage directly accessible on every model response and in message history sequences.
• ›Adds support for non-string enums in Gemini model integrations.

PydanticAI v0.1.11 renames the CLI entry point to clai.

$ git clone --branch v0.1.11 https://github.com/pydantic/pydantic-ai.git
# already have the repo? check out this version:
$ git checkout v0.1.11

• ›Renames the CLI entry point to clai, replacing the previous command name.

PydanticAI v0.1.10 adds extra_headers to ModelSettings and thinking_config to GeminiModel

$ git clone --branch v0.1.10 https://github.com/pydantic/pydantic-ai.git
# already have the repo? check out this version:
$ git checkout v0.1.10

from pydantic_ai import Agent
from pydantic_ai.settings import ModelSettings

agent = Agent(
    'openai:gpt-4o',
    model_settings=ModelSettings(extra_headers={'X-Custom-Header': 'my-value'})
)
result = agent.run_sync('Hello')

• ›Adds extra_headers field to ModelSettings to pass custom HTTP headers to model API calls.
• ›Adds thinking_config parameter to GeminiModel to control extended thinking behavior.
• ›Allows setting temperature to 0 on BedrockConverseModel for deterministic outputs.

PydanticAI v0.1.9 adds base_url support for Mistral, richer Anthropic usage details, and multi-modal MCP tool call responses.

$ git clone --branch v0.1.9 https://github.com/pydantic/pydantic-ai.git
# already have the repo? check out this version:
$ git checkout v0.1.9

from pydantic_ai.providers.mistral import MistralProvider

provider = MistralProvider(base_url='https://my-mistral-instance.example.com/v1')

• ›Adds base_url parameter to the Mistral provider, enabling custom or self-hosted Mistral endpoint configuration.
• ›Stores additional usage details returned by Anthropic in the response metadata.
• ›Handles multi-modal and error responses from MCP tool calls, broadening the range of MCP tool outputs PydanticAI can process.

Semantic Kernel .NET 1.54.0 adds AIContextProvider support and a Summary property on OpenApiOperation.

$ git clone --branch dotnet-1.54.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.54.0

• ›Adds AIContextProvider support to Semantic Kernel, enabling context injection into AI interactions.
• ›Adds Summary property to the OpenApiOperation model class, exposing operation summaries from OpenAPI specs.
• ›Removes the Kusto and DuckDB integrations from the .NET SDK.

Semantic Kernel .NET 1.53.0 exposes ToJson on FoundryProcessBuilder, integrates MEAI Abstractions, and updates the Azure Foundry Agent SDK.

$ git clone --branch dotnet-1.53.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.53.0

• ›Exposes ToJson method on FoundryProcessBuilder, allowing serialization of a Foundry process definition to JSON.
• ›Integrates Semantic Kernel with MEAI (Microsoft Extensions for AI) Abstractions, enabling interoperability with the MEAI abstraction layer.
• ›Updates the Azure Foundry Agent SDK backing AzureAIAgent, with GA Foundry Projects (created on or after May 19th, 2025) now accessed via endpoint URI instead of connection-string.

Semantic Kernel Python 1.31.0 adds Magentic multi-agent orchestration and WebRTC support for Azure OpenAI Realtime.

$ git clone --branch python-1.31.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.31.0

• ›Adds Magentic multi-agent orchestration strategy, enabling coordinated multi-agent workflows via the new MagenticOrchestration pattern.
• ›Adds WebRTC support for Azure OpenAI Realtime, enabling real-time audio/video communication through the Azure OpenAI Realtime connector.
• ›Preserves citation title in AnnotationContent from Azure AI Foundry annotations.

Semantic Kernel dotnet-1.52.0 adds Magentic multi-agent orchestration and MEVD feature updates for .NET, plus Magentic orchestration and planner deprecation for Python.

$ git clone --branch dotnet-1.52.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.52.0

• ›Adds Magentic Agent Orchestration for .NET (Microsoft.SemanticKernel.Agents) enabling multi-agent coordination via the Magentic pattern.
• ›Adds Magentic multi-agent orchestration support for Python, aligning orchestration capabilities across both SDK surfaces.
• ›Updates .NET codebase to the latest MCP (Model Context Protocol) NuGet package, keeping MCP integration current.
• ›Updates Microsoft.Extensions.AI dependency to its stable release version in the .NET SDK.
• ›Ships MEVD (Memory and Vector Data) Feature Branch 3 for .NET, advancing the vector/memory subsystem.

Semantic Kernel vectordata-dotnet-9.5.0 adds Magentic agent orchestration, MCP Streamable HTTP, Copilot Studio Agent, and IEmbeddingGenerator support for VectorStoreTextSearch.

$ git clone --branch vectordata-dotnet-9.5.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout vectordata-dotnet-9.5.0

var textSearch = new VectorStoreTextSearch<MyRecord>(vectorStore, embeddingGenerator);

settings = OpenAIChatPromptExecutionSettings(extra_body={"reasoning_effort": "high"})

await process.start(kernel=kernel, initial_event=start_event, max_supersteps=20)

• ›Adds IEmbeddingGenerator support to VectorStoreTextSearch in .NET, enabling use of the M.E.AI embedding abstraction for vector text search.
• ›Adds extra_body attribute to OpenAIChat settings in Python for passing arbitrary extra parameters to the OpenAI chat API.
• ›Adds max_supersteps parameter for callers to control process execution limits in Python processes.
• ›Introduces Magentic multi-agent orchestration pattern for .NET Agents, enabling LLM-driven dynamic agent selection and coordination.
• ›Introduces Copilot Studio Agent for Python, enabling integration with Microsoft Copilot Studio as an agent provider.

Semantic Kernel .NET 1.51.0 adds FoundryProcessBuilder for local runtime and multi-agent orchestration support.

$ git clone --branch dotnet-1.51.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.51.0

• ›Adds FoundryProcessBuilder for local runtime process execution in .NET.
• ›Adds .NET Agent Orchestration support, enabling coordination of multiple agents.
• ›Obsoletes ITextEmbeddingGenerator in .NET, signaling a migration path away from the interface.

Semantic Kernel .NET 1.50.0 adds URL citation support for Azure Agents and serialized Python code execution results.

$ git clone --branch dotnet-1.50.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.50.0

• ›Adds URL citation support on AzureAgent in .NET, surfacing source links from Azure AI agent responses.
• ›Serializes Python code execution results in .NET, making interpreter output available as structured data.
• ›Updates Microsoft.Extensions.AI (MEAI) dependency and migrates away from deprecated schema APIs.

Semantic Kernel Python 1.30.0 adds Copilot Studio Agent, MCP Streamable HTTP, and four multi-agent orchestration patterns

$ git clone --branch python-1.30.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.30.0

from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings

settings = OpenAIChatPromptExecutionSettings(
    extra_body={'reasoning_effort': 'high', 'store': True}
)

• ›Adds extra_body attribute to OpenAI Chat settings, enabling pass-through of arbitrary request body fields to the OpenAI API.
• ›Introduces CopilotStudioAgent, a new agent type for integrating with Microsoft Copilot Studio.
• ›Ports the Agent Runtime into the SK repo, enabling local multi-agent execution without an external runtime dependency.
• ›Adds support for MCP Streamable HTTP transport alongside the existing transports.
• ›Adds multi-agent orchestration: ConcurrentOrchestration and SequentialOrchestration patterns for coordinating agent pipelines.

Semantic Kernel .NET 1.49.0 adds IEmbeddingGenerator support in vector search, graduates Plugins.Core to preview, and introduces BinaryContent in OpenAI.

$ git clone --branch dotnet-1.49.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.49.0

from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings

settings = OpenAIChatPromptExecutionSettings(
    extra_body={"reasoning_effort": "high", "data_sources": []}
)

• ›Adds IEmbeddingGenerator support to VectorStoreTextSearch, enabling the Microsoft.Extensions.AI embedding abstraction as a drop-in source for vector store text search.
• ›Supports BinaryContent in the .NET OpenAI Connector, allowing binary payloads to be passed through OpenAI requests.
• ›Graduates Microsoft.SemanticKernel.Plugins.Core package from 'alpha' to 'preview' status, signalling increased API stability.
• ›Removes the experimental attribute from core plugins in Plugins.Core, making them part of the stable surface.
• ›Migrates the Python code interpreter C# plugin (SessionsPythonPlugin) to the latest Azure code interpreter API version.

browser-use 0.2.2 adds auto-detection of LLM tool-calling method and LLM API verification at startup.

$ git clone --branch 0.2.2 https://github.com/browser-use/browser-use.git
# already have the repo? check out this version:
$ git checkout 0.2.2

• ›Auto-detects the LLM tool-calling method and verifies the LLM API connection at startup, catching misconfiguration before a session begins.
• ›Improves file upload detection for more reliable browser automation workflows.

browser-use 0.2.1 ships BrowserProfile/BrowserSession, per-domain sensitive data, Patchright support, and expanded vector store providers

$ git clone --branch 0.2.1 https://github.com/browser-use/browser-use.git
# already have the repo? check out this version:
$ git checkout 0.2.1

from playwright.async_api import async_playwright
from browser_use import Agent

async with async_playwright() as p:
    browser = await p.chromium.launch()
    page = await browser.new_page()
    await page.goto('https://example.com')

    agent = Agent(task='fill out this form', llm=llm, page=page)
    await agent.run()

from browser_use import Controller
from playwright.async_api import Page

controller = Controller()

@controller.registry.action(
    description='Highlight all cells in the selection',
    allowed_domains=['https://docs.google.com']
)
async def highlight_cells(cell_range: str, page: Page):
    await page.evaluate(f"document.querySelector('{cell_range}').style.background = 'yellow'")

• ›Introduces BrowserProfile and BrowserSession classes, replacing Browser, BrowserConfig, BrowserContext, and BrowserContextConfig with a unified API that accepts all standard Playwright launch_persistent_context() arguments directly on BrowserProfile.
• ›Adds allowed_domains parameter to BrowserSession, now defaulting to enforcing https:// unless http:// or http*:// is explicitly included; supports globs and full scheme matching (e.g. https://*.google.com, chrome-extension://*).
• ›Changes Agent(sensitive_data) to accept a new per-domain format {domain: {key: val, ...}} instead of the flat {key: value} format, restricting credential exposure to matching domains using the same glob/scheme system as allowed_domains.
• ›Allows passing existing Playwright (or Patchright) Page, BrowserContext, and Browser objects directly into BrowserSession or Agent (e.g. Agent(task='...', llm=llm, page=page)).
• ›Adds support for using Patchright as a stealth browser backend via playwright=await async_patchright().start() on BrowserSession.

browser-use 0.1.48 adds glob pattern support for allowed_domains URL restrictions and automated Docker Hub publishing.

$ git clone --branch 0.1.48 https://github.com/browser-use/browser-use.git
# already have the repo? check out this version:
$ git checkout 0.1.48

from browser_use import Agent

agent = Agent(
    task="Find the pricing page",
    allowed_domains=['*.example.com'],
    llm=llm,
)

• ›Adds glob pattern matching to allowed_domains (e.g. allowed_domains=['*.example.com']), enabling wildcard-based URL allowlisting for browser agents.
• ›Docker images are now automatically published to Docker Hub via CI on each release.

browser-use 0.1.47 renames GEMINI_API_KEY to GOOGLE_API_KEY and moves CLI deps to an optional install group.

$ git clone --branch 0.1.47 https://github.com/browser-use/browser-use.git
# already have the repo? check out this version:
$ git checkout 0.1.47

• ›Renames the GEMINI_API_KEY environment variable to GOOGLE_API_KEY for Google model authentication.
• ›Moves CLI dependencies to an optional browser-use[cli] install group, keeping the core library lighter for non-CLI users.
• ›Adds LLaMA model to the built-in pricing table for cost tracking.

browser-use 0.1.46 adds a Dockerfile, switches back to Playwright, and improves element interaction and DOM integrity.

$ git clone --branch 0.1.46 https://github.com/browser-use/browser-use.git
# already have the repo? check out this version:
$ git checkout 0.1.46

• ›Adds Dockerfile and .dockerignore for containerizing browser-use deployments.
• ›Switches the underlying browser automation backend from patchright back to playwright for improved performance and stability.
• ›Automatically clicks elements before typing into them, with a fallback to simulating keystrokes on the entire page for better input reliability.

browser-use 0.1.45 adds an interactive CLI, Google Sheets support, Azure OpenAI, and improved anti-bot fingerprint evasion.

$ git clone --branch 0.1.45 https://github.com/browser-use/browser-use.git
# already have the repo? check out this version:
$ git checkout 0.1.45

from browser_use import BrowserContextConfig

config = BrowserContextConfig(window_width=1280, window_height=900, no_viewport=False)

• ›Adds flat window_width and window_height attributes to BrowserContextConfig (replacing the removed BrowserWindowContextSize object), also used as viewport dimensions when no_viewport=False.
• ›New interactive CLI for browser-use, styled like the claude code CLI, for running browser-use tasks directly from the terminal.
• ›Adds Google Sheets support directly in the main controller.
• ›Adds support for Azure OpenAI API GPT-4 as a model provider.
• ›Improves anti-bot fingerprint detection for compatibility with Cloudflare-protected sites and Google logins.

browser-use 0.1.42 adds anti-bot detection via patchright, Playwright script generation, force_new_context flag, and embedder config for Mem0.

$ git clone --branch 0.1.42 https://github.com/browser-use/browser-use.git
# already have the repo? check out this version:
$ git checkout 0.1.42

from browser_use import Agent, BrowserConfig

browser_config = BrowserConfig(
    chrome_remote_debugging_port=9222,
    force_new_context=True
)
agent = Agent(task='...', llm=llm, browser_config=browser_config)

• ›Adds force_new_context=True flag to browser config so custom context configuration is applied when connecting to existing browsers.
• ›Adds chrome_remote_debugging_port setting in browser config to support launching user-provided Chrome browsers.
• ›Adds GEMINI_API_KEY environment variable, replacing GOOGLE_API_KEY for Gemini LLM authentication.
• ›Adds Playwright script generation from agent history, enabling replay of recorded agent sessions.
• ›Adds anti-bot detection support by integrating patchright as the underlying browser automation backend, replacing playwright.

camel-ai v0.2.60 adds streamable HTTP, Jina Reranker API support, extra Azure OpenAI headers, and new Gemini model types.

$ git clone --branch v0.2.60 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.60

• ›Adds streamable HTTP transport support for real-time, streaming agent communication.
• ›Adds Jina Reranker API support, enabling remote reranking calls alongside the existing local reranker.
• ›Adds support for passing extra headers to Azure OpenAI requests.
• ›Adds updated Gemini model types including corrected support for Gemini 2.0 Flash.

camel-ai v0.2.59 adds an Airbnb MCP integration and the BrowseComp benchmark for CAMEL agents.

$ git clone --branch v0.2.59 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.59

• ›Integrates the BrowseComp benchmark, enabling evaluation of CAMEL agents on complex, multi-step web browsing tasks.
• ›Adds an Airbnb MCP integration use case, demonstrating CAMEL agents operating as MCP clients against an Airbnb MCP server.

camel-ai v0.2.58 adds a MarkItDown loader, MCP search agent, async BrowserToolkit, and Gemini 2.5 Pro preview support.

$ git clone --branch v0.2.58 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.58

from camel.loaders import MarkItDownLoader

loader = MarkItDownLoader()
docs = loader.load("report.pdf")

• ›Adds gemini-2.5-pro-preview-05-06 as a supported model in the GEMINI model family.
• ›Adds a MarkItDown document loader for ingesting files via Microsoft's MarkItDown library.
• ›Adds an MCP search agent enabling agent workflows driven by Model Context Protocol tool servers.
• ›Adds async support to BrowserToolkit, enabling non-blocking browser automation in async agent pipelines.
• ›Improves MCP server launch with a better interface and support for all connection modes.

camel-ai v0.2.56 adds async Mistral support, Mistral Medium model, and a Playwright MCP toolkit.

$ git clone --branch v0.2.56 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.56

• ›Adds async implementation to the Mistral model integration, enabling non-blocking LLM calls.
• ›Adds support for the mistral-medium model.
• ›Adds a Playwright MCP toolkit for browser automation within agent workflows.

camel-ai v0.2.55 adds Agent-as-MCP-server, Pulse MCP search, Klavis AI toolkit, and timeout control for MCP sessions.

$ git clone --branch v0.2.55 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.55

from camel.toolkits import MCPToolkit

config = {
    "mcpServers": {
        "my_server": {
            "url": "http://localhost:8000"
        }
    }
}
toolkit = MCPToolkit(config=config)

• ›Adds MCPServer capability to expose a CAMEL agent as an MCP server, letting other MCP clients connect to and invoke the agent directly.
• ›Adds support for passing a Dict as config to the MCP toolkit, complementing the existing file-based config approach.
• ›Adds a timeout argument to MCP session initialization, enabling control over how long the client waits for MCP server responses.
• ›Adds Pulse MCP search toolkits, enabling agents to search the Pulse MCP registry.
• ›Adds list_tools and call_tool functions to the Klavis AI toolkit, allowing agents to enumerate and invoke Klavis AI tools.

camel-ai v0.2.53 adds Gemini embeddings, ACI tool interface, MCP for non-function-calling models, and richer ChatAgent control.

$ git clone --branch v0.2.53 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.53

• ›Adds termination parameter to ChatAgent.step() and ChatAgent.astep() to allow callers to inject custom termination conditions at call time.
• ›Enables ModelFactory to accept and pass through additional keyword arguments when constructing model instances.
• ›Adds Gemini embedding support via the existing embeddings interface.
• ›Introduces ACI tool interface (ACI_Tool_interface) for interacting with ACI-based tools.
• ›Enables MCP (Model Context Protocol) for models that do not natively support function calling, expanding MCP compatibility beyond function-calling-capable backends.

camel-ai v0.2.52 adds Klavis toolkit, Daytona runtime integration, and a strict parameter for MCP classes.

$ git clone --branch v0.2.52 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.52

from camel.toolkits import MCPToolkit

toolkit = MCPToolkit(config_path="mcp_config.json", strict=True)

• ›Adds strict parameter to the constructors of MCPClient and MCPToolkit classes for stricter MCP connection control.
• ›Adds KlavisToolkit integration for connecting to the Klavis API.
• ›Integrates Daytona runtime support for sandboxed code execution environments.

camel-ai v0.2.51 adds DeepSeek Prover V2 671B via PPIO, SingleStepEnv timeout, and Azure AD token provider support.

$ git clone --branch v0.2.51 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.51

• ›Adds azure_ad_token_provider support to Azure OpenAI integration, enabling token-based authentication flows.
• ›Adds timeout parameter to SingleStepEnv, enabling time-bounded environment execution.
• ›Adds DeepSeek Prover V2 671B model support via the PPIO provider.

camel-ai v0.2.50 adds Novita and WatsonX LLM providers, Qwen3 support, a Physics verifier, and browser toolkit caching.

$ git clone --branch v0.2.50 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.50

• ›Adds Novita as a new LLM provider integration.
• ›Integrates IBM WatsonX as a new LLM provider.
• ›Adds Qwen3 model support via both ModelScope and the qwen_model backend.
• ›Adds a Physics verifier for validating physics-related agent outputs.
• ›Adds caching capability to the Browser Toolkit, reducing redundant network calls.

HolmesGPT 0.11.1 adds RabbitMQ, Elasticsearch, AKS, and Git toolsets plus Prometheus auto-discovery and multi-tenant Loki/Grafana support.

$ git clone --branch 0.11.1 https://github.com/HolmesGPT/holmesgpt.git
# already have the repo? check out this version:
$ git checkout 0.11.1

$ holmes ask --prompt-file ./prompts/oom-investigation.txt

$ AWS_PROFILE=prod-sre holmes ask 'Why is the payment service crashing?'

• ›Adds --prompt-file argument to the holmes ask command to supply investigation prompts from a file.
• ›Adds AWS_PROFILE support in Bedrock model requirements for named AWS profile selection.
• ›New RabbitMQ toolset for querying RabbitMQ broker state during investigations.
• ›New Elasticsearch toolset for querying Elasticsearch during investigations.
• ›New Azure Kubernetes Service (AKS) toolset, including a dedicated AKS node health toolset and support for specifying the AKS environment.

smolagents v1.16.0 adds Bing search, custom executor functions, code timeouts, and local web agent CLI support

$ git clone --branch v1.16.0 https://github.com/huggingface/smolagents.git
# already have the repo? check out this version:
$ git checkout v1.16.0

$ smolagents --api_base http://localhost:8000 --api_key sk-localkey

• ›Adds executor_kwargs parameter to LocalPythonExecutor for initialization customization of the local Python executor.
• ›Adds timeout mechanism for code execution in the local Python executor.
• ›Enables local web agents via api_base and api_key CLI arguments.
• ›Supports passing custom functions to the local Python executor.
• ›Adds Bing as a supported search engine in WebSearchTool.

smolagents v1.15.0 adds streaming model output, a LiteLLM Router model, and a new WebSearchTool.

$ git clone --branch v1.15.0 https://github.com/huggingface/smolagents.git
# already have the repo? check out this version:
$ git checkout v1.15.0

• ›Adds LiteLLMRouterModel to support LiteLLM Router as a model backend, enabling load-balanced or fallback routing across LLM providers.
• ›Adds WebSearchTool, replacing DuckDuckGoSearchTool as the recommended built-in web search tool.
• ›Adds streaming model output support, including streaming Gradio chatbot outputs; introduces ChatMessageStreamDelta as the stream delta type.
• ›Moves MCPClient to the root-level library and manages its dependencies as optional.

Aider v0.83.0 adds shell completions, Playwright scraping, co-author commits, OCaml repo-map, and new model support.

$ git clone --branch v0.83.0 https://github.com/Aider-AI/aider.git
# already have the repo? check out this version:
$ git checkout v0.83.0

$ aider --attribute-co-authored-by --no-attribute-author --no-attribute-committer

• ›Adds support for gemini-2.5-pro-preview-05-06 and qwen3-235b models.
• ›Adds repo-map support for OCaml and OCaml interface files.
• ›Introduces --attribute-co-authored-by flag to add a co-author trailer to commit messages, with --attribute-author/--attribute-committer overrides for fine-grained control.
• ›Adds --disable-playwright flag to prevent Playwright installation prompts and usage.
• ›Adds --shell-completions argument to generate shell completion scripts (bash, zsh, etc.).

Cline v3.17.2 adds Claude 4 (Sonnet 4 & Opus 4) on AWS Bedrock/Vertex AI and introduces global shared workflows.

$ git clone --branch v3.17.2 https://github.com/cline/cline.git
# already have the repo? check out this version:
$ git checkout v3.17.2

• ›Supports Claude 4 models (Sonnet 4 and Opus 4) via AWS Bedrock and Vertex AI providers.
• ›Adds global workflows that are shared across workspaces, with local workflows taking precedence over global ones.

Cline v3.17.1 adds prompt caching for Claude 4 models and doubles Opus 4's max token limit to 8192.

$ git clone --branch v3.17.1 https://github.com/cline/cline.git
# already have the repo? check out this version:
$ git checkout v3.17.1

• ›Adds prompt caching support for Claude 4 models on Cline and OpenRouter providers, reducing latency and cost on repeated context.
• ›Increases max output tokens for Claude Opus 4 from 4096 to 8192, enabling longer single-turn responses.

Cline v3.17.0 adds Claude Sonnet 4/Opus 4 support, Nebius AI Studio integration, and a redesigned tabbed settings page.

$ git clone --branch v3.17.0 https://github.com/cline/cline.git
# already have the repo? check out this version:
$ git checkout v3.17.0

• ›Supports Anthropic Claude Sonnet 4 and Claude Opus 4 via both the Anthropic and Vertex providers.
• ›Integrates Nebius AI Studio as a new AI provider option.
• ›Redesigns the settings page with a tabbed layout for easier navigation, consolidating all advanced settings in one place.
• ›Adds a custom highlight and hotkey suggestion when the assistant prompts the user to switch to Act mode.

Cline v3.16.3 adds Gemini 2.5 Flash on Vertex AI, a new keyboard shortcut, and lightbulb code actions for selected text.

$ git clone --branch v3.16.3 https://github.com/cline/cline.git
# already have the repo? check out this version:
$ git checkout v3.16.3

• ›Supports Gemini 2.5 Flash Preview 05-20 model via Vertex AI provider with a 1M token context window.
• ›Adds keyboard shortcut (Cmd+') to focus the Cline panel from anywhere in VS Code.
• ›Adds lightbulb code actions for selected text: 'Add to Cline', 'Explain with Cline', and 'Improve with Cline'.
• ›Automatically focuses the Cline window after extension updates.

Cline v3.16.2 adds Gemini 2.5 Flash on Vertex AI, a focus shortcut, and inline lightbulb actions for selected code.

$ git clone --branch v3.16.2 https://github.com/cline/cline.git
# already have the repo? check out this version:
$ git checkout v3.16.2

• ›Supports Gemini 2.5 Flash Preview 05-20 via Vertex AI provider with a 1M-token context window.
• ›New keyboard shortcut (Cmd+') focuses the Cline panel from anywhere in VS Code.
• ›Adds VS Code lightbulb actions for selected text: 'Add to Cline', 'Explain with Cline', and 'Improve with Cline'.
• ›Automatically focuses the Cline window after extension updates.

Cline v3.16.1 adds an auto-approve toggle and improved Gemini retry feedback.

$ git clone --branch v3.16.1 https://github.com/cline/cline.git
# already have the repo? check out this version:
$ git checkout v3.16.1

• ›Adds an Enable Auto Approve toggle switch to turn auto-approve on or off without losing configured action settings.
• ›Improves Gemini API retry handling with clearer UI feedback showing retry progress during request attempts.

Cline v3.16.0 adds slash-command workflows, collapsible task history, and a Vertex AI global endpoint option.

$ git clone --branch v3.16.0 https://github.com/cline/cline.git
# already have the repo? check out this version:
$ git checkout v3.16.0

• ›Adds a workflow feature letting users create and manage workflow files injected into conversations via slash commands.
• ›Adds a collapsible recent task list so users can hide task history during screen sharing.
• ›Adds a global endpoint option for Vertex AI, improving availability and reducing 429 rate-limit errors.
• ›Adds detection for new users to surface onboarding components and guidance.

Cline v3.15.4 restores Gemini on Vertex AI, adds Gemini telemetry, and enables workspace-scoped task filtering.

$ git clone --branch v3.15.4 https://github.com/cline/cline.git
# already have the repo? check out this version:
$ git checkout v3.15.4

• ›Adds Gemini model back to the Vertex AI provider, restoring access to Gemini via Google Cloud.
• ›Adds telemetry support for Gemini model usage.
• ›Enables filtering of tasks scoped to the current workspace.

Cline v3.15.3 adds Fireworks as a new API provider.

$ git clone --branch v3.15.3 https://github.com/cline/cline.git
# already have the repo? check out this version:
$ git checkout v3.15.3

• ›Adds Fireworks as a supported API provider.

Cline v3.15.2 adds detailed LiteLLM config options, improved auto-approve controls, and implicit caching for Gemini.

$ git clone --branch v3.15.2 https://github.com/cline/cline.git
# already have the repo? check out this version:
$ git checkout v3.15.2

• ›Adds detailed configuration options for the LiteLLM provider.
• ›Adds more granular controls and details to the auto-approve menu with more sensible defaults.
• ›Enables implicit caching for Gemini models via OpenRouter and Cline providers.
• ›Adds webview telemetry for opted-in users.

Cline v3.15.0 adds task timelines, favorites, quote-reply, commit-message generation, and Gemini implicit caching.

$ git clone --branch v3.15.0 https://github.com/cline/cline.git
# already have the repo? check out this version:
$ git checkout v3.15.0

• ›Adds Task Timeline visualization to tasks for a chronological view of agent activity.
• ›Adds ability to favorite a task, preserving it when clearing all task history.
• ›Adds support for quoting a previous message in chat.
• ›Adds ability to type the next message while Cline is still taking action, reducing idle wait time.
• ›Adds commit message generation via Cline.

Cline v3.14.0 adds custom AWS Bedrock model IDs, LaTeX rendering, configurable API timeouts, batch history deletion, and a /newrule slash command.

$ git clone --branch v3.14.0 https://github.com/cline/cline.git
# already have the repo? check out this version:
$ git checkout v3.14.0

$ /newrule

• ›Supports custom model IDs in the AWS Bedrock provider, enabling use of Application Inference Profiles.
• ›Adds Amazon Nova Premier model to AWS Bedrock.
• ›Supports LaTeX rendering in chat output.
• ›Enables configurable API request timeouts for OpenRouter/Cline and Ollama providers (previously hard-coded at 15–30 s).
• ›Adds a configurable timeout for terminal connection startup.

Continue v1.0.21 for JetBrains adds SSE/Streamable-HTTP MCP, markdown rules, requestRule tool, alwaysApply rule property, and Claude Sonnet 4 support.

$ git clone --branch v1.0.21-jetbrains https://github.com/continuedev/continue.git
# already have the repo? check out this version:
$ git checkout v1.0.21-jetbrains

---
name: Security Baseline
description: Always-on security coding guidelines
alwaysApply: true
---

Never log secrets. Sanitize all user input before use.

models:
  - name: my-model
    provider: openai
    model: gpt-4o
    defaultCompletionOptions:
      stream: true
      maxStopWords: 4

• ›Adds alwaysApply property to rules for unconditional rule application regardless of context matching.
• ›Adds description field in markdown YAML front-matter for rule files.
• ›Adds stream key to defaultCompletionOptions in YAML config to control streaming behavior.
• ›Adds maxStopWords model config option in YAML for controlling stop-word limits.
• ›Adds requestRule tool enabling the agent to fetch and apply rules on demand.

Continue v1.0.10 adds custom MCP timeouts, SSE custom headers, Watsonx Messages API, and Llama 4/Codestral model support.

$ git clone --branch v1.0.10-vscode https://github.com/continuedev/continue.git
# already have the repo? check out this version:
$ git checkout v1.0.10-vscode

• ›Adds custom MCP timeout configuration, letting users override the default connection timeout for MCP servers.
• ›Adds support for custom headers in SSE transport, enabling authenticated or enterprise SSE MCP connections.
• ›Adds Watsonx Messages API integration as a supported provider.
• ›Adds Llama 4 Scout Cerebras to the model definition schema.
• ›Adds a Codestral prompt template.

Continue v1.0.9 adds globs to rules, Mistral/DeepSeek agent support, new providers, and a Lazy Edit tool.

$ git clone --branch v1.0.9-vscode https://github.com/continuedev/continue.git
# already have the repo? check out this version:
$ git checkout v1.0.9-vscode

globs: ["**/*.ts"]
name: typescript-style
description: Enforce TypeScript conventions
content: Always use strict null checks and explicit return types.

models:
  - name: my-reasoning-model
    provider: anthropic
    model: claude-3-7-sonnet-latest
    reasoning: true
    reasoningBudgetTokens: 8000

models:
  - name: ollama-codellama
    provider: ollama
    model: codellama
    num_gpu: 35

• ›Adds globs field to rules in config to scope which files a rule applies to, and to the create-rule tool so agents can write glob-scoped rules.
• ›Adds standalone template parameter to YAML model config for controlling prompt formatting.
• ›Adds reasoning and reasoningBudgetTokens parameters to config schemas for models that support extended reasoning.
• ›Adds num_gpu support for Ollama models in config.
• ›Adds Mistral models as supported providers in Agent mode.

Continue v1.0.8 adds a create_rule_block tool, autocomplete prompt templates, HuggingFace/Voyage re-additions, and Azure o3/o4 tool support.

$ git clone --branch v1.0.8-vscode https://github.com/continuedev/continue.git
# already have the repo? check out this version:
$ git checkout v1.0.8-vscode

• ›Adds create_rule_block tool, enabling AI agents to programmatically create rule blocks during a session.
• ›Adds autocomplete prompt template configuration, giving users control over how autocomplete suggestions are generated.
• ›Re-adds HuggingFace and Voyage as supported provider integrations.
• ›Adds tool-calling support for Azure-hosted o3 and o4 models.
• ›Introduces the Continue SDK (feat: continue sdk), exposing a programmatic interface for extending Continue.

Goose v1.0.23 adds GitHub Copilot provider, a /summarize slash command, session search, and full --resume message loading.

$ git clone --branch v1.0.23 https://github.com/block/goose.git
# already have the repo? check out this version:
$ git checkout v1.0.23

$ /summarize

• ›Adds GitHub Copilot as a supported LLM provider.
• ›New /summarize slash command lets users trigger context summarization directly from the CLI.
• ›Adds a summarize-on-command button for context management in the UI.
• ›Loads all previous messages when --resume is passed, enabling full session continuity.
• ›Adds search to the sessions list for faster session navigation.

Goose v1.0.22 adds GitHub-based recipe retrieval, file drag-and-drop, a global hotkey, runtime metrics, and Mac keyboard shortcuts.

$ git clone --branch v1.0.22 https://github.com/block/goose.git
# already have the repo? check out this version:
$ git checkout v1.0.22

$ goose run --recipe <recipe>.yaml --headless

$ goose bench --output-dir <path>

• ›Supports configurable retrieval of recipes via GitHub, enabling teams to share and version-control recipe libraries centrally.
• ›Enables drag-and-drop of files directly into the Goose desktop window for faster context attachment.
• ›Adds a global hotkey to bring up Goose from anywhere on the desktop.
• ›Exposes runtime metrics in completion responses, giving visibility into model execution performance.
• ›Adds Mac keyboard shortcuts to the desktop UI.

OpenCode v0.0.51 adds non-interactive mode with tool restriction flags, F9 tools dialog, image paste, and full 0-255 color themes.

$ git clone --branch v0.0.51 https://github.com/sst/opencode.git
# already have the repo? check out this version:
$ git checkout v0.0.51

$ opencode --non-interactive --allow-tools read_file,grep "Summarize the authentication flow in src/auth/"

• ›Adds non-interactive mode for scripted/CI use cases without a live terminal session.
• ›Adds tool restriction flags to control which tools are available when running in non-interactive mode.
• ›Adds a tools dialog accessible via F9 to browse and inspect available tools from within the TUI.
• ›Supports 0-255 (xterm-256) color range in custom themes for richer terminal styling.
• ›Enables configuring the shell via the config file instead of relying solely on the environment default.

OpenCode v0.0.50 adds VertexAI as a supported LLM provider.

$ git clone --branch v0.0.50 https://github.com/sst/opencode.git
# already have the repo? check out this version:
$ git checkout v0.0.50

• ›Adds VertexAI provider support, enabling use of Google Cloud Vertex AI models.

OpenCode v0.0.49 adds a batch tool, named arguments in custom commands, WebP image preview, and an improved status bar.

$ git clone --branch v0.0.49 https://github.com/sst/opencode.git
# already have the repo? check out this version:
$ git checkout v0.0.49

• ›New batch tool enables running multiple tool calls in a single operation.
• ›Custom commands now support named arguments for more flexible command definitions.
• ›Supports previewing WebP images and pasting file paths directly in the TUI.
• ›Improved status bar with better information display.

OpenCode v0.0.48 adds slash-triggered completions dialog and persistent model selection config.

$ git clone --branch v0.0.48 https://github.com/sst/opencode.git
# already have the repo? check out this version:
$ git checkout v0.0.48

• ›New completions module with a dialog UI and multiple providers, triggered by typing /.
• ›Adds configuration persistence for model selections so chosen models are remembered across sessions.

OpenCode 0.0.45 adds auto LSP discovery, auto-compact summarization, and a new logs page.

$ git clone --branch 0.0.45 https://github.com/sst/opencode.git
# already have the repo? check out this version:
$ git checkout 0.0.45

• ›Adds automatic LSP discovery and configuration — no manual language-server setup required.
• ›Adds auto-compact/summarize to keep long-running sessions going indefinitely without hitting context limits.
• ›New logs page for inspecting session activity directly in the UI.

OpenHands 0.38.0 adds Windows runtime, MCP config UI, self-hosted Git support, and user/org microagents.

$ git clone --branch 0.38.0 https://github.com/All-Hands-AI/OpenHands.git
# already have the repo? check out this version:
$ git checkout 0.38.0

• ›Adds self-hosted GitLab and enterprise GitHub host settings for local installations.
• ›Supports user-defined runners for the resolver, enabling custom execution environments.
• ›Adds Windows local runtime support with PowerShell.
• ›Enables the agent to save browser screenshots as image files during sessions.
• ›Supports loading custom Agent implementations from arbitrary Python packages via config.toml.

OpenHands 0.37.0 adds branch picker for repositories and per-user configurable conversation starters.

$ git clone --branch 0.37.0 https://github.com/All-Hands-AI/OpenHands.git
# already have the repo? check out this version:
$ git checkout 0.37.0

• ›Adds a branch picker for repository selection on the homepage.
• ›Enables per-user configuration of proactive conversation starters for Cloud Resolver, togglable in account settings (enabled by default).
• ›Adds helpful tips to the Changes tab zero state.

OpenHands 0.36.0 adds CLI agent pause/resume, documentation search, and raises the conversation panel limit to 20.

$ git clone --branch 0.36.0 https://github.com/All-Hands-AI/OpenHands.git
# already have the repo? check out this version:
$ git checkout 0.36.0

• ›Adds pause and resume functionality for agents running in the CLI.
• ›Adds search support for documentation within the product.
• ›Separates settings into multiple distinct sections in the UI.
• ›Increases the conversation panel limit from 9 to 20.

Zed v0.187.7 adds Claude 4 support on AWS Bedrock and handles Claude 4 refusal stop reasons.

$ git clone --branch v0.187.7 https://github.com/zed-industries/zed.git
# already have the repo? check out this version:
$ git checkout v0.187.7

• ›Changes the default value of diagnostics_max_severity from warning to hint.
• ›Adds support for Claude 4 models via AWS Bedrock.
• ›Adds handling for "stop_reason": "refusal" responses from Claude 4 models.

Zed v0.187.4 adds a minimap, image support in hover docs, new UI settings, and agent image support for Gemini and OpenAI.

$ git clone --branch v0.187.4 https://github.com/zed-industries/zed.git
# already have the repo? check out this version:
$ git checkout v0.187.4

{
  "minimap": {
    "show": "always"
  }
}

{
  "hover_popover_delay": 600
}

• ›Adds minimap for high-level overview and quick navigation; enable with "minimap": {"show": "always"} in settings.
• ›Adds hover_popover_delay setting to control the delay in milliseconds before the informational hover box appears.
• ›Adds "search": {"button": false}, "diagnostics": {"button": false}, "title_bar": {"show_project_items": false}, and "title_bar": {"show_branch_name": false} settings to hide UI buttons.
• ›Adds included_files field to the DeploySearch action to pre-fill file inclusion filters, enabling keybindings scoped to specific folders or file sets.
• ›Adds terminal::RerunTask action to re-run the last terminal task.

Zed v0.186.10 adds image input support for OpenAI models in the Agent.

$ git clone --branch v0.186.10 https://github.com/zed-industries/zed.git
# already have the repo? check out this version:
$ git checkout v0.186.10

• ›Adds input image support for OpenAI models in the Agent panel.
• ›Improves inline assistant behavior to focus existing assistants when the cursor is placed on their line, matching selection behavior.

Zed v0.186.7 adds debugger beta, SOCKS proxy auth, new config keys, and editor::GoToParentModule for Rust.

$ git clone --branch v0.186.7 https://github.com/zed-industries/zed.git
# already have the repo? check out this version:
$ git checkout v0.186.7

{
  "workspace": {
    "title_bar": {
      "show_onboarding_banner": false
    }
  }
}

{
  "skip_focus_for_active_in_search": false
}

• ›Adds workspace.title_bar.show_onboarding_banner preference to hide onboarding banners.
• ›Adds skip_focus_for_active_in_search setting for the file finder, allowing users to turn off the default behavior of skipping focus on the active file during searches.
• ›Relocates workspace.show_user_picture preference to workspace.title_bar.show_user_picture.
• ›Adds ctrl-r keybinding to refresh diagnostics in the project diagnostics editor context.
• ›Adds editor::GoToParentModule action for rust-analyzer-backed Rust projects.

Zed v0.185.16 adds image support for Copilot Chat, new AI models, and agent panel zoom controls.

$ git clone --branch v0.185.16 https://github.com/zed-industries/zed.git
# already have the repo? check out this version:
$ git checkout v0.185.16

• ›Supports zooming the agent panel via workspace::ToggleZoom action, also accessible from the panel's menu.
• ›Adds image support for Copilot Chat models in the Agent panel.
• ›Dynamically detects available Copilot Chat models, including all models with tool support.
• ›Adds support for Amazon Nova Premier model.
• ›Adds support for Amazon Pixtral Large 25.02 v1 model.

Zed v0.185.14 adds fuzzy search to Agent model selection and renders edit tool errors as Markdown.

$ git clone --branch v0.185.14 https://github.com/zed-industries/zed.git
# already have the repo? check out this version:
$ git checkout v0.185.14

• ›Agent model selection now supports fuzzy search for faster model switching.
• ›Agent edit tool errors now render as Markdown and are selectable.

Zed v0.185.13 adds mistral-medium support and per-thread Agent profile selection.

$ git clone --branch v0.185.13 https://github.com/zed-industries/zed.git
# already have the repo? check out this version:
$ git checkout v0.185.13

• ›Adds mistral-medium to the Mistral provider in the Agent configuration.
• ›Saves profile selection per Agent thread, so each thread remembers its own profile independently.

Zed v0.185.12 lets you open the root directory / as an SSH project folder and improves the SSH project picker.

$ git clone --branch v0.185.12 https://github.com/zed-industries/zed.git
# already have the repo? check out this version:
$ git checkout v0.185.12

• ›Supports opening / as a project folder over SSH, enabling direct root-level remote project access.
• ›SSH project picker now shows the full path to the remote home directory instead of ~ as its initial state.

Zed v0.185.10 introduces the Agent Panel for AI-powered code editing.

$ git clone --branch v0.185.10 https://github.com/zed-industries/zed.git
# already have the repo? check out this version:
$ git checkout v0.185.10

• ›Introduces the Agent Panel, a new UI surface for AI-powered editing within the editor.

Zed v0.185.9 adds an Agent Panel for AI editing, merge conflict resolution, VS Code settings import, and new Git/tab controls.

$ git clone --branch v0.185.9 https://github.com/zed-industries/zed.git
# already have the repo? check out this version:
$ git checkout v0.185.9

{
  "git_panel": {
    "sort_by_path": true
  }
}

• ›Adds zed::ImportVsCodeSettings action to import settings from VS Code.
• ›Adds tab_switcher::ToggleAll action to search open tabs across all panes and focus the selected one.
• ›Adds git_panel.sort_by_path setting to mix untracked and tracked files together in the diff list.
• ›Increases the default value of expand_excerpt_lines from 3 to 5 in the git diff view for more context.
• ›Introduces the Agent Panel for agentic AI-powered editing.

KoboldCpp v1.91 adds a Hugging Face model browser, embedded aria2c downloader, CFG support via --enableguidance, and expanded Corpo mode.

$ git clone --branch v1.91 https://github.com/LostRuins/koboldcpp.git
# already have the repo? check out this version:
$ git checkout v1.91

$ koboldcpp.exe --model mymodel.gguf --enableguidance

• ›Adds --enableguidance flag (or Enable Guidance checkbox in UI) to enable Classifier-Free Guidance (CFG); configure a negative prompt and CFG scale via the lite tokens menu — note CFG doubles KV usage and halves generation speed.
• ›New Hugging Face Model Search Tool lets users search, browse, and download GGUF models directly from Hugging Face within KoboldCpp before launch.
• ›Embeds aria2c downloader in Windows builds for high-speed model downloads when using provided URLs.
• ›Adds CUDA compute capability 3.5 target, potentially enabling GPU acceleration on K6000, GTX 780, and K80 hardware.
• ›Removes flash attention limits and warnings for Vulkan backends.

oobabooga textgen v3.3 adds VRAM estimation with auto gpu-layers for GGUF and Tools support for the OpenAI-compatible API.

$ git clone --branch v3.3 https://github.com/oobabooga/textgen.git
# already have the repo? check out this version:
$ git checkout v3.3

$ python server.py --model mistral-7b-instruct-v0.2.Q5_K_M.gguf --ctx-size 32768 --cache-type q4_0

• ›Automatically estimates VRAM usage for GGUF models and sets gpu-layers based on free VRAM on NVIDIA GPUs; recalculates in real time when ctx-size or cache-type changes in the UI.
• ›When loading a GGUF model via CLI (e.g. --model model.gguf --ctx-size 32768 --cache-type q4_0), --gpu-layers is now calculated automatically — no manual flag required.
• ›Adds Tools support for the OpenAI-compatible API.
• ›Adds the top_n_sigma sampler to the llama.cpp loader.
• ›Renders max_updates_second obsolete with a new dynamic Chat Message UI update speed that substantially reduces CPU usage in Chat mode.

oobabooga textgen v3.2 adds Qwen3 thinking toggle, auto API port selection, and verbose llama-server logging

$ git clone --branch v3.2 https://github.com/oobabooga/textgen.git
# already have the repo? check out this version:
$ git checkout v3.2

• ›Adds enable_thinking checkbox under Parameters to enable or disable thinking for Qwen3 models (and future models with the feature); thinking is enabled by default and works via the Jinja2 template.
• ›Automatically finds a new API port if the default one is already taken.
• ›Makes --verbose print the llama-server launch command to the console.
• ›Makes <think> UI blocks closed by default, reducing visual noise from reasoning model output.

Ollama v0.8.0 adds streaming support for tool call responses.

$ git clone --branch v0.8.0 https://github.com/ollama/ollama.git
# already have the repo? check out this version:
$ git checkout v0.8.0

• ›Streams responses that include tool calls, enabling real-time output during tool-augmented LLM interactions.
• ›Adds improved memory estimate debug information in logs when running models in Ollama's engine.

Ollama v0.7.1 adds Qwen 3 & Qwen 2 multimodal support and truncation indicators in ollama show.

$ git clone --branch v0.7.1 https://github.com/ollama/ollama.git
# already have the repo? check out this version:
$ git checkout v0.7.1

• ›Supports Alibaba's Qwen 3 and Qwen 2 architectures in Ollama's multimodal engine.
• ›ollama show now displays ... when output data is truncated.