The AI Toolchain — issue -367, April 30, 2025

Agno v1.4.2 adds MCP SSE transport, tool hooks, shared team session state, and new Cartesia, Gemini, and Groq tool integrations.

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

• ›Adds MCP SSE transport support, enabling agents to connect to SSE MCP Servers alongside the existing transport options.
• ›Adds tool hooks that wrap around all tool calls for both Toolkits and custom tools, enabling pre/post-call logic across every tool invocation.
• ›Adds shared Team Session State — a single state dictionary accessible across a team leader and all team members via tools given to the leader or members.
• ›Adds CartesiaTool for text-to-speech capabilities using Cartesia.
• ›Adds a Gemini image tool for generating images using Gemini models.

Agno v1.4.1 adds meeting notification sending and richer PubMed article data to its toolkits.

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

• ›Adds option in the Google Calendar / meeting toolkit to send meeting notifications to attendees when creating or updating events.
• ›Enhances PubmedTools with more comprehensive article data, returning additional metadata fields beyond basic citation info.

Agno v1.4.0 promotes Memory to GA, adds OpenAITools and ZepTools, and brings include/exclude tool filtering to all toolkits.

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

from agno.tools.some_toolkit import SomeToolkit

agent = Agent(
    tools=[SomeToolkit(include_tools=["search", "fetch"])],
)

• ›Adds include_tools and exclude_tools parameters to all toolkits, enabling selective enabling/disabling of individual tools inside larger toolkits.
• ›Adds OpenAITools class to enable text-to-speech and image generation through OpenAI's APIs.
• ›Adds ZepTools and AsyncZepTools classes to manage Agent memories via zep-cloud.
• ›Promotes Agentic user Memory management from beta to generally available, with enable_user_memories and enable_session_summaries now set directly on the Agent or Team.
• ›Adds reasoning model support (e.g. Deepseek-R1) via Azure AI Foundry.

Agno v1.3.5 adds async support for five vector DBs, reasoning events on RunResponse, and Google Gemini cache support.

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

• ›Populates reasoning_content on RunResponse for all reasoning types across stream/non-stream and async/non-async modes, with a unified JSON structure for Reasoning events.
• ›Adds async support for ClickHouse, ChromaDB, Cassandra, PineconeDB, and Pgvector vector database backends.
• ›Adds Google Gemini caching support: cache files and send cached content to Gemini models.

Agno v1.3.4 adds a web browser tool, proxy support for URL and PDF readers, and improved memory management.

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

from agno.embedder.azure_openai import AzureOpenAIEmbedder

embedder = AzureOpenAIEmbedder(
    client_params={
        'api_version': '2024-02-01',
        'azure_deployment': 'my-embedding-deployment'
    }
)

• ›Adds proxy parameter to the URL reader, enabling requests through a proxy when fetching remote content.
• ›Adds proxy parameter to the PDF reader, enabling proxy-routed PDF retrieval.
• ›Adds client_params argument support to AzureOpenAIEmbedder, allowing custom client parameters to be passed through.
• ›Adds mode attribute to Team class data serialization, exposing team mode in serialized output.
• ›Adds a new webbrowser tool for agents to interact with web browsers.

Agno v1.3.3 adds Ollama and AzureOpenAI reasoning support, Gemini file upload, and expanded token metrics.

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

• ›Adds audio, reasoning, and cached token counts to metrics where available across models.
• ›Enables native reasoning model support for Ollama and AzureOpenAI providers.
• ›Enables direct use of uploaded files with Gemini models.

Agno v1.3.2 adds Redis as a Memory storage backend and new agent convenience methods for session and user memory retrieval.

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

summary = agent.get_session_summary()
user_memories = agent.get_user_memories()
print(summary)
print(user_memories)

• ›Adds add_member_tools_to_system_message to team configuration, allowing the member tool names to be removed from the system message sent to the team leader for broader transfer-function compatibility.
• ›Adds agent.get_session_summary() method to retrieve the previous session summary from an agent.
• ›Adds agent.get_user_memories() method to retrieve the current user's memories from an agent.
• ›Supports Redis as a storage provider for Memory, enabling persistent memory backed by Redis.
• ›Supports additional instructions on MemoryManager and SessionSummarizer for customizing memory behavior.

Agno v1.3.0 revamps Memory with a new class, adds user/session params to agent.run(), and ships Redis session storage.

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

agent.run("What did I order last time?", user_id="user-42", session_id="session-abc123")

• ›Adds user_id and session_id parameters to agent.run(), scoping memory access to a single user and session to enable multi-user, multi-session applications from one agent configuration.
• ›Introduces a new Memory class (beta) supporting add, update, delete, and semantic search over user memories, with agent-driven memory management.
• ›Adds Redis as a session storage provider.

Agno v1.2.16 adds knowledge bases with agentic RAG to Teams, mirroring existing Agent functionality.

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

team = Team(
    members=[agent1, agent2],
    knowledge=knowledge_base,
    retriever=my_custom_retriever,
    search_knowledge=True,
)

• ›Adds knowledge, retriever, and search_knowledge fields to Team, enabling knowledge bases and agentic RAG on teams (previously only available on Agent).
• ›Improves Teams task forwarding reliability and makes the team leader more conversational, with new reasoning-with-teams examples.

Agno v1.2.14 adds expanded GithubTools, async MongoDB VectorDB support, and stream_intermediate_resp on print_response.

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

agent.print_response(stream_intermediate_resp=True)

• ›Adds stream_intermediate_resp parameter to print_response for streaming intermediate responses.
• ›Expands GithubTools with many additional capabilities.
• ›Adds async support for MongoDB as a vector database, enabling use in async knowledge bases.
• ›Converts all utility scripts to be Windows-compatible.

Agno v1.2.12 adds ReasoningTools, timezone-aware agents, and Google Cloud JSON session storage

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

from agno.agent import Agent

agent = Agent(
    timezone_identifier="America/New_York",
    # ... other params
)

from agno.agent import Agent
from agno.tools.reasoning import ReasoningTools

agent = Agent(
    tools=[ReasoningTools()],
    # ... other params
)

• ›Adds timezone_identifier parameter to the Agent class to include the agent's timezone alongside the current date in its instructions.
• ›Adds ReasoningTools class providing an advanced reasoning scratchpad for agents.
• ›Adds JSON-based session storage on Google Cloud via a new Google Cloud Storage backend for memory/session state.
• ›Extends async/await support to URLKnowledgeBase, FireCrawlKnowledgeBase, and DocxKnowledgeBase for non-blocking knowledge base operations.
• ›Enables thinking support for the @tool decorator.

Agno v1.2.10 adds KnowledgeTools for agent-driven thinking, searching, and document analysis over a knowledge base.

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

from agno.tools.knowledge import KnowledgeTools

agent = Agent(
    knowledge=knowledge_base,
    tools=[KnowledgeTools(knowledge=knowledge_base)],
)

• ›Adds KnowledgeTools class enabling agents to think, search, and analyse documents within a knowledge base.

Agno v1.2.9 adds MultiMCPTools for connecting agents to multiple MCP servers in a single interface.

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

from agno.tools.mcp import MultiMCPTools

tools = MultiMCPTools(
    commands=[
        "npx -y @modelcontextprotocol/server-filesystem /tmp",
        "npx -y @modelcontextprotocol/server-brave-search"
    ]
)

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

• ›Adds MultiMCPTools class to connect agents to multiple MCP servers simultaneously, with a simplified interface that only accepts command.
• ›Updates Gemini model support for structured outputs when tools are in use.

Agno v1.2.8 adds instructions and add_instructions to Toolkit so tool usage guidance flows into the model system message.

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

from agno.tools import Toolkit

class MySearchToolkit(Toolkit):
    def __init__(self):
        super().__init__(
            name="my_search",
            instructions="Always prefer recent results. Limit queries to 10 words.",
            add_instructions=True,
        )

    def search(self, query: str) -> str:
        ...

• ›Adds instructions and add_instructions fields to the Toolkit class, allowing per-toolkit usage instructions to be injected into the model's system message when add_instructions=True.

Agno v1.2.7 adds Gemini image generation, async knowledge base/vector DB support, and result caching on all toolkits.

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

import asyncio
from agno.knowledge.pdf import PDFKnowledgeBase

kb = PDFKnowledgeBase(path='reports/')
asyncio.run(kb.aload())

• ›Adds image generation via the gemini-2.0-flash-exp-image-generation model, enabling agents to produce images directly through Gemini.
• ›Adds result caching to all Agno Toolkits and any custom functions decorated with @tool.
• ›Adds async/await support to LanceDb, Milvus, and Weaviate vector DBs, enabling use in agent.arun and agent.aprint_response.
• ›Adds async/await support to JSONKnowledgeBase, PDFKnowledgeBase, PDFUrlKnowledgeBase, CSVKnowledgeBase, CSVUrlKnowledgeBase, ArxivKnowledgeBase, WebsiteKnowledgeBase, YoutubeKnowledgeBase, and TextKnowledgeBase.
• ›Enables knowledge_base.aload() for async knowledge base loading, substantially increasing ingestion speed in async contexts.

AutoGPT Platform v0.6.7 adds agent forking, Prometheus execution metrics, and a billing page toggle.

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

• ›Exposes execution Prometheus metrics for monitoring agent runs.
• ›Adds a billing page toggle to the UI.
• ›Enables forking agents directly from the Library, creating editable copies of existing agents.
• ›Adds retry logic on executor process initialization to improve resilience.
• ›Uses forkserver process creation strategy where available for improved executor process handling.

AutoGPT Platform beta v0.6.6 adds the latest LLM models to the platform.

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

• ›Adds the latest LLM models as selectable options for agents.

AutoGPT Platform v0.6.5 adds wallet top-up, auto-refill, and credentials UX for library agents.

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

• ›Adds credentials UX on the /library/agents/[id] page, letting users manage agent credentials directly from the agent library.
• ›Adds wallet top-up and auto-refill functionality to the platform's billing/credit system.
• ›Updates the completed task group design in the Wallet UI.
• ›Adds a retry mechanism for pika publish_message to improve message delivery reliability.

AutoGPT Platform v0.6.4 migrates execution queue to RabbitMQ and adds onboarding phase 2.

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

• ›Migrates the agent execution queue and cancel mechanism to RabbitMQ, replacing the previous RPC service in the Agent Executor.
• ›Implements Onboarding Phase 2 for new users.
• ›Adds Sentry environment tracking on the frontend and initializes Sentry in app services for observability.

AutoGPT Platform v0.6.2 adds a generic webhook block, real-time execution updates, advanced block search, and Llama 4 model support.

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

• ›Adds a generic webhook block, enabling agents to trigger or receive arbitrary webhook events.
• ›Adds advanced block search with relevance ranking, making it faster to find the right block in large agent graphs.
• ›Adds support for Llama 4 Maverick and Llama 4 Scout models as available LLM options.
• ›Adds real-time execution updates for the platform library, surfacing live agent run status without manual refresh.
• ›Adds a real-time 'Steps' count to the agent run view so practitioners can monitor execution progress as it happens.

CrewAI 0.117.0 adds result_as_answer decorator support, GPT-4.1/Gemini-2.x models, and a HuggingFace CLI provider.

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

from crewai.tools import tool

@tool(result_as_answer=True)
def lookup_cve(cve_id: str) -> str:
    """Fetch CVE details from internal database."""
    return fetch_cve_record(cve_id)

• ›Adds result_as_answer parameter to the @tool decorator, allowing a tool's output to be used directly as the agent's final answer.
• ›Supports new language models: GPT-4.1, Gemini-2.0, and Gemini-2.5 Pro.
• ›Adds HuggingFace as a provider option in the CrewAI CLI.
• ›Enhances knowledge management capabilities.

CrewAI 0.114.0 lets agents run standalone, adds custom LLM support, external memory, and Opik observability.

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

from crewai import Agent

researcher = Agent(
    role="Research Analyst",
    goal="Find the latest CVEs for Apache HTTP Server",
    backstory="You are an expert in vulnerability research.",
    llm="gpt-4o"
)

result = researcher.kickoff()
print(result)

• ›Enables agents as atomic, standalone units — call Agent(...).kickoff() without a full Crew.
• ›Supports custom LLM implementations for bringing your own model client.
• ›Integrates External Memory for persistent agent knowledge across runs.
• ›Adds Opik observability integration for tracing and monitoring agent workflows.
• ›Adds wildcard support to emit() for flexible event broadcasting.

DSPy 2.6.20 adds native async support for callbacks and dspy.Tool, plus MCP tool integration via dspy.Tool.from_mcp_tool.

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

import dspy

# mcp_tool is an MCP-protocol tool object from your MCP session
dspy_tool = dspy.Tool.from_mcp_tool(mcp_tool)

agent = dspy.ReAct(signature="question -> answer", tools=[dspy_tool])
result = agent(question="What is the current price of AAPL?")

• ›Adds dspy.Tool.from_mcp_tool class method to construct a dspy.Tool directly from an MCP tool, enabling Model Context Protocol integration.
• ›Adds native async support for callbacks and dspy.Tool, allowing asynchronous execution throughout the DSPy module pipeline.

DSPy 2.6.19 adds async support on critical paths, a fanout cache, and expanded dspy.Tool argument handling.

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

import dspy

def search(query: str, **kwargs) -> str:
    # kwargs can carry optional parameters like top_k, filters, etc.
    return f"Results for {query}"

tool = dspy.Tool(search)
react = dspy.ReAct("Answer the question.", tools=[tool])
result = react(question="What is the capital of France?")

import asyncio
import dspy

dspy.configure(lm=dspy.LM("openai/gpt-4o"))
qa = dspy.ChainOfThought("question -> answer")

async def main():
    results = await asyncio.gather(
        qa.acall(question="What is SSRF?"),
        qa.acall(question="What is SSTI?"),
    )
    print(results)

asyncio.run(main())

• ›Supports composite argument type parsing in dspy.Tool, enabling richer type hints for tool inputs.
• ›Supports kwargs in dspy.Tool, allowing tools to accept variable keyword arguments.
• ›Allows overwriting max_iter at runtime in ReAct, giving per-invocation control over agent loop depth.
• ›Adds async support across DSPy critical paths, enabling non-blocking LM calls in async workflows.
• ›Introduces a fanout cache for DSPy, enabling parallel cache lookups to reduce latency.

DSPy 2.6.18 adds global num_threads/provide_traceback settings, a two-step adapter, streaming support, and default args in dspy.Tool.

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

import dspy

dspy.settings.configure(
    num_threads=16,
    provide_traceback=True,
)

lm = dspy.LM('openai/gpt-4o')
dspy.settings.configure(lm=lm)

import dspy

def search(query: str, top_k: int = 5) -> list:
    ...

tool = dspy.Tool(search)  # default top_k=5 is preserved automatically

• ›Moves num_threads into dspy.settings so thread concurrency can be configured globally instead of per-call.
• ›Moves provide_traceback into dspy.settings for global traceback control across all modules.
• ›Adds a maximum size cap for the global history to bound memory growth during long runs.
• ›Introduces a two-step adapter for improved structured-output handling.
• ›Supports default argument values in dspy.Tool, reducing boilerplate when wrapping functions with optional parameters.

Haystack v2.12.0 adds an Agent component with state management, SuperComponent for reusable pipelines, AutoMergingRetriever, and Azure AD token support.

$ git clone --branch v2.12.0 https://github.com/deepset-ai/haystack.git
# already have the repo? check out this version:
$ git checkout v2.12.0

from haystack import Pipeline, SuperComponent

with open("rag_pipeline.yaml", "r") as f:
    pipeline = Pipeline.load(f)

wrapper = SuperComponent(
    pipeline=pipeline,
    input_mapping={
        "query": ["retriever.query", "prompt_builder.query"],
    },
    output_mapping={"llm.replies": "replies"},
)

result = wrapper.run(query="What is the capital of France?")
print(result["replies"])

from haystack.components.preprocessors import CSVDocumentSplitter

splitter = CSVDocumentSplitter(split_mode="row-wise")
result = splitter.run(documents=docs)

• ›Adds outputs_to_string parameter to Tool and ComponentTool to customize how tool output is converted into a string before being passed back to the ChatGenerator in a ChatMessage.
• ›Adds split_mode parameter to CSVDocumentSplitter to control splitting mode; supports row-wise splitting in addition to the previous default threshold behavior.
• ›Adds link_format parameter to DOCXToDocument (accepts 'markdown' or 'plain') to optionally include extracted hyperlink addresses in output Documents.
• ›Adds azure_ad_token_provider parameter to AzureOpenAIGenerator, AzureOpenAIChatGenerator, AzureOpenAITextEmbedder, and AzureOpenAIDocumentEmbedder for Azure AD bearer-token authentication via a callable.
• ›Introduces default_azure_token_provider utility function in haystack/utils/azure.py as a serializable default token provider for Azure AD authentication.

langchain-core 0.3.56rc1 adds multi-modal content blocks, PDF/audio Chat Completions support, token-counting callback, and richer tool/prompt APIs.

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

from langchain_core.tools import tool

@tool(description='Fetches the current weather for a given city.')
def get_weather(city: str) -> str:
    ...

• ›Adds convert_to_openai_messages support for standard multi-modal blocks (images, files, audio) and auto-generates filenames when converting file content blocks to OpenAI format.
• ›Supports PDF and audio input in the Chat Completions format via core and standard-tests.
• ›Adds tool_call exclusion filter in filter_message to strip tool-call entries from message lists.
• ›Adds a token-counting callback handler (de-betaed usage callback) that stores model names per invocation.
• ›Adds scoped_full as a new clean-up strategy for the indexing API.

LangChain Community 0.3.22 adds OAuth2 for Jira, Managed Identity for Azure AI Search, bind variables for Oracle ADB, custom runtimes for Riza, and more.

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

• ›Adds oauth2 support to the Jira toolkit, enabling OAuth2-based authentication flows.
• ›Adds Managed Identity support for Azure AI Search integration.
• ›Adds bind variable support for the Oracle ADB document loader.
• ›Adds support for custom runtimes to Riza tools.
• ›Adds usage_metadata support for LiteLLM streaming calls.

langchain-openai 0.3.14 adds standard audio input support and relaxes multimodal content block field requirements.

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

• ›Adds support for standard audio inputs in OpenAI integrations, enabling audio modality in LangChain standard tests.
• ›Permits optional fields on multimodal content blocks, giving more flexibility when constructing mixed-media messages.

langchain-tests 0.3.18 adds multi-modal content block support across multiple integrations.

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

• ›Adds multi-modal content block support across multiple components, enabling richer message payloads beyond plain text.

langchain-core 0.3.52 adds multi-modal content blocks, dict-based chat prompt templates, and customizable retry backoff parameters.

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

• ›Supports customization of backoff parameters in with_retries for finer control over retry behavior.
• ›Adds multi-modal content blocks support across multiple components, enabling richer message payloads.
• ›Adds dict-based chat prompt template support, allowing prompt templates to be defined as plain dicts.
• ›Shares a single executor for async callbacks run in a sync context, improving async callback efficiency.
• ›Uses a custom __getattr__ in __init__.py files for lazy imports, reducing import-time overhead.

langchain-xai 0.2.3 adds support for reasoning content in xAI model responses.

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

• ›Supports reasoning content in xAI model responses, enabling access to chain-of-thought or scratchpad output returned by reasoning-capable xAI models.

LangChain Community 0.3.21 adds SAP HANA dialect, Gremlin edge properties, reasoning content for LiteLLM, and several loader enhancements.

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

from langchain_community.document_loaders import GitbookLoader

loader = GitbookLoader(
    'https://docs.example.com',
    sitemap_url='https://docs.example.com/custom-sitemap.xml',
    load_all_paths=True
)
docs = loader.load()

from langchain_community.document_loaders import PlaywrightURLLoader

loader = PlaywrightURLLoader(
    urls=['https://internal.example.com/dashboard'],
    storage_state='playwright_session.json'
)
docs = loader.load()

• ›Adds sitemap_url parameter to GitbookLoader to support custom sitemap URLs.
• ›Adds PlaywrightURLLoader support for a stored session file, enabling authenticated browser sessions.
• ›Adds keep_newlines parameter to the process_pages method for finer control over page text formatting.
• ›Adds SAP HANA dialect support to SQLDatabase.
• ›Adds edge properties to the Gremlin graph schema output.

LangChain 0.3.23 adds a dedicated Perplexity partner integration and deprecates the community ChatPerplexity.

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

• ›Adds a first-party Perplexity extra (partner integration) for ChatPerplexity, replacing the community-package version.
• ›Deprecates the community version of ChatPerplexity in favour of the new partner integration.

langchain-openai 0.3.12 adds structured output and tools support plus token counting for o-series models in ChatOpenAI.

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

• ›Supports structured output and tools in ChatOpenAI, enabling constrained JSON responses and function-calling workflows.
• ›Adds token counting support for o-series models (e.g. o1, o3) in ChatOpenAI, with file blocks ignored during token counting.

LangGraph SDK 0.1.65 adds sorting support to assistants search with new sort_by and sort_order parameters.

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

results = await client.assistants.search(sort_by="updated_at", sort_order="desc")

• ›Adds sort_by and sort_order parameters to Client.search for assistants, enabling sorting by assistant_id, graph_id, name, created_at, or updated_at in ascending or descending order.
• ›Introduces new type aliases AssistantSortBy, ThreadSortBy, and SortOrder for strongly-typed sort parameter hints across assistant and thread searches.

LangGraph 0.4.1 adds incremental UI message merging and drops Pydantic V1 support.

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

from langgraph.graph.ui import push_ui_message

# First emission creates the message
push_ui_message("my-component", {"status": "loading"}, message_id="msg-1")

# Subsequent call merges new props into the existing message
push_ui_message("my-component", {"status": "done", "result": "42"}, message_id="msg-1", merge=True)

• ›Adds a merge parameter to push_ui_message enabling incremental/partial updates to existing UI messages without replacing them wholesale.
• ›Drops Pydantic V1 support — SchemaCoercionMapper and langgraph.utils.pydantic now exclusively use Pydantic V2 APIs.

LangGraph 0.4.0 adds targeted interrupt resumption by ID and exposes pending interrupts on StateSnapshot

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

graph.invoke(Command(resume={interrupt.interrupt_id: "approved"}), config)

snapshot = graph.get_state(config)
for interrupt in snapshot.interrupts:
    print(interrupt.interrupt_id, interrupt.value)

• ›Adds interrupt_id property on Interrupt that generates a unique ID from its namespace, enabling precise identification of individual interrupts.
• ›Enhances Command.resume to accept a mapping of interrupt IDs to resume values, allowing targeted resumption of specific interrupts rather than all-or-nothing.
• ›Adds interrupts field to StateSnapshot to track interrupts that occurred in a step and are pending resolution.
• ›Propagates interrupts in "values" stream mode so invoke/ainvoke and streaming consumers now see interrupts emitted during graph execution.
• ›Adds add_edge utility in graph visualization to prevent duplicate edges when rendering graphs with END nodes.

LangGraph checkpoint savers gain delete_thread and adelete_thread methods to remove all data for a given thread ID.

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

from langgraph.checkpoint.memory import InMemorySaver

saver = InMemorySaver()

# synchronous
saver.delete_thread(thread_id="thread-abc123")

# async
await saver.adelete_thread(thread_id="thread-abc123")

• ›Adds delete_thread and adelete_thread methods to BaseCheckpointSaver and InMemorySaver for deleting all checkpoints and writes associated with a specific thread ID.

LangGraph 0.3.32 adds draw_graph for graph visualization and get_static_writes for static analysis of conditional edges.

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

from langgraph.pregel.draw import draw_graph

draw_graph(compiled_graph)

• ›Adds get_static_writes method to ChannelWrite to support static analysis of what a writer might write, enabling better resolution of conditional edges.
• ›Extends ChannelWrite.register_writer to accept static declarations for writers, with a new static field on ChannelWriteTupleEntry to declare writes for static analysis.
• ›Adds new langgraph.pregel.draw module with a draw_graph function that simulates execution to discover edges, correctly handling subgraphs and conditional edges.

LangGraph CLI gains --image option to deploy pre-built Docker images without a rebuild step.

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

$ langgraph up --image my-custom-langgraph-image:latest

• ›Adds --image option to langgraph up to specify a pre-built Docker image for the langgraph-api service, skipping the build process entirely.

LangGraph CLI 0.2.6 adds --tunnel flag to expose local dev server publicly via Cloudflare.

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

$ langgraph dev --tunnel

• ›Adds --tunnel flag to the dev command to expose the local LangGraph API server through a public Cloudflare tunnel, enabling remote frontend access without localhost restrictions.

LangGraph SDK 0.1.62 adds sort_by and sort_order parameters to thread search for ordered result retrieval.

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

threads = await client.threads.search(
    sort_by="updated_at",
    sort_order="desc"
)

• ›Adds sort_by and sort_order parameters to Client.search for sorting thread results by id, status, created_at, or updated_at in ascending or descending order.

LangGraph Postgres checkpoint library adds thread deletion and tightens search method signatures.

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

saver = PostgresSaver(conn)
saver.delete_thread(thread_id="thread-abc123")

saver = AsyncPostgresSaver(conn)
await saver.adelete_thread(thread_id="thread-abc123")

• ›Adds delete_thread method to PostgresSaver for complete removal of all checkpoints and writes tied to a specific thread ID.
• ›Adds adelete_thread (async) and delete_thread (sync, with main-thread safety checks) to AsyncPostgresSaver for the same capability in async workflows.
• ›Updates search on PostgresStore and asearch on AsyncPostgresStore to require query as an explicit keyword argument rather than a positional parameter.

LangGraph CLI 0.2.5 adds internal config option to override Docker tags in generated Dockerfiles.

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

{
  "_INTERNAL_docker_tag": "3.11-slim-bookworm"
}

• ›Adds _INTERNAL_docker_tag configuration option to override the default Docker tag used in generated Dockerfiles, falling back to the Python or Node.js version when not set.

LangGraph 0.3.31 adds CONFIG_KEY_THREAD_ID constant for tracking thread IDs in concurrent graph invocations.

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

from langgraph.constants import CONFIG_KEY_THREAD_ID

def my_node(state, config):
    thread_id = config["configurable"].get(CONFIG_KEY_THREAD_ID)
    print(f"Running on thread: {thread_id}")
    return state

• ›New langgraph.constants.CONFIG_KEY_THREAD_ID constant enables explicit tracking of thread IDs for current invocations in checkpointing and state management.

LangGraph 0.3.28 adds support for multiple retry policies per node or task, applying the first matching policy on exception.

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

from langgraph.types import RetryPolicy
from langgraph.graph import StateGraph

rate_limit_policy = RetryPolicy(retry_on=RateLimitError, max_attempts=5, backoff_factor=2.0)
network_policy = RetryPolicy(retry_on=ConnectionError, max_attempts=2, backoff_factor=1.0)

graph = StateGraph(MyState)
graph.add_node("my_node", my_node_fn, retry=[rate_limit_policy, network_policy])

from langgraph.func import task
from langgraph.types import RetryPolicy

@task(retry=[RetryPolicy(retry_on=TimeoutError, max_attempts=3), RetryPolicy(retry_on=Exception, max_attempts=1)])
def fetch_data(url: str):
    ...

• ›Supports passing a sequence of retry policies to StateGraph.add_node, langgraph.func.task, and Pregel, applying the first matching policy when an exception occurs.
• ›Improves SchemaCoercionMapper performance with functools.lru_cache caching, fast paths for basic types, and better handling of tuple, set, and other collection types.
• ›Adds compatibility with both Pydantic v1 and v2 in schema coercion via SchemaCoercionMapper.

LangGraph CLI 0.2.2 adds auto-detection of Python/JS graphs and smarter Docker base-image selection for mixed-language projects.

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

• ›Automatically detects Python and JavaScript graphs by file extension, eliminating manual language configuration.
• ›Selects the appropriate Docker base image automatically based on project composition via new default_base_image logic.
• ›Supports mixed Python/Node.js projects in a single configuration, with validate_config now auto-detecting and setting correct runtime versions for each graph file.
• ›New docker_tag utility generates correct Docker image tags based on project configuration.

LangGraph 0.3.27 adds checkpoint_during parameter to skip per-step checkpointing and boost large-graph performance.

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

result = graph.invoke({"messages": messages}, config=config, checkpoint_during=False)

async for chunk in graph.astream({"messages": messages}, config=config, checkpoint_during=False):
    process(chunk)

• ›Adds checkpoint_during parameter to stream(), astream(), invoke(), and ainvoke() — set to False to checkpoint only at run end, reducing overhead in large graphs.

LangGraph CLI now accepts dictionary-format graph definitions with a 'path' key in addition to plain import-path strings.

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

• ›Supports dictionary-format graph definitions (with a 'path' key) in the configuration file, alongside the existing plain import-path string format, enabling additional metadata to be co-located with graph paths.

LangGraph 0.3.25 adds a UI messaging system to push, remove, and reduce UI component updates during graph execution.

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

from langgraph.graph.ui import push_ui_message, delete_ui_message, ui_message_reducer

# Inside a graph node:
def my_node(state):
    msg = push_ui_message("progress-card", {"status": "running", "step": 1})
    # ... do work ...
    delete_ui_message(msg["id"])
    return state

from typing import Annotated
from langgraph.graph.ui import AnyUIMessage, ui_message_reducer
from typing_extensions import TypedDict

class GraphState(TypedDict):
    ui: Annotated[list[AnyUIMessage], ui_message_reducer]

• ›New UIMessage TypedDict represents UI component updates with properties and metadata during graph execution.
• ›New RemoveUIMessage TypedDict enables removal of UI components from the current graph state.
• ›New AnyUIMessage Union type combines UIMessage and RemoveUIMessage for flexible type annotations.
• ›New push_ui_message() function creates and sends UI messages to render components mid-execution.
• ›New delete_ui_message() function removes a UI component from state by ID.

LangGraph prebuilt 0.1.8 adds a pre_model_hook to create_react_agent for trimming or summarizing long message histories before LLM calls.

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

from langgraph.prebuilt import create_react_agent
from langchain_core.messages import trim_messages

def pre_model_hook(state):
    trimmed = trim_messages(state["messages"], max_tokens=4096, token_counter=len)
    return {"llm_input_messages": trimmed}

agent = create_react_agent(
    model=llm,
    tools=tools,
    pre_model_hook=pre_model_hook,
)

def summarizing_hook(state):
    messages = state["messages"]
    if len(messages) > 20:
        summary = llm.invoke(f"Summarize this conversation: {messages[:-5]}")
        return {"llm_input_messages": [summary] + messages[-5:]}
    return {"llm_input_messages": messages}

agent = create_react_agent(
    model=llm,
    tools=tools,
    pre_model_hook=summarizing_hook,
)

• ›Adds pre_model_hook parameter to create_react_agent, letting you inject a custom node before every LLM call to preprocess message history via trimming, summarization, or other logic.
• ›Hook can return messages to update agent state or llm_input_messages to reshape only what the LLM sees, leaving persisted state untouched.

LangGraph CLI 0.1.84 adds custom UI configuration support for dev server and Docker builds.

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

• ›Supports ui and ui_config options in config files for customized UI when running langgraph dev.
• ›Docker image builds now automatically detect and install UI dependencies (npm, yarn, pnpm, bun) when UI is configured.
• ›Docker images now include LANGGRAPH_UI and LANGGRAPH_UI_CONFIG environment variables when UI is configured.

LangGraph SDK 0.1.61 adds description support to assistant create and update methods.

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

assistant = await client.assistants.create(
    graph_id="my-graph",
    description="Triages incoming support tickets and routes to the correct queue."
)

await client.assistants.update(
    assistant_id="asst_abc123",
    description="Revised: handles both support tickets and billing inquiries."
)

• ›Adds optional description field to AssistantBase TypedDict for storing assistant descriptions.
• ›Adds description parameter to create and update methods (async and sync) on the assistants client.

LangGraph checkpoint 2.0.24 adds explicit None serialization support in JsonPlusSerializer.

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

from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer

serde = JsonPlusSerializer()
type_tag, data = serde.dumps_typed(None)  # returns ("null", b"")
value = serde.loads_typed((type_tag, data))  # returns None

• ›Supports None values in JsonPlusSerializer via a new "null" type designation, enabling round-trip serialization of null checkpoint state fields.

LangGraph 0.3.23 adds REMOVE_ALL_MESSAGES to clear entire conversation histories in one operation.

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

from langgraph.graph.message import REMOVE_ALL_MESSAGES
from langchain_core.messages import RemoveMessage

# Pass this to your graph state update to discard all prior messages
state_update = {"messages": [RemoveMessage(id=REMOVE_ALL_MESSAGES)]}

• ›Adds REMOVE_ALL_MESSAGES constant to wipe an entire MessageGraph conversation history in a single RemoveMessage call.

LangGraph CLI 0.1.83 adds TTL-based checkpointer config for automatic thread data cleanup in deployments.

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

from langgraph_cli.config import CheckpointerConfig, ThreadTTLConfig

checkpointer = CheckpointerConfig(
    ttl=ThreadTTLConfig(
        default_minutes=1440,   # delete thread data older than 24 hours
        sweep_interval_minutes=60,
        strategy="delete",
    )
)

• ›Adds CheckpointerConfig class to configure the built-in checkpointer in LangGraph deployments via the main config file.
• ›Adds ThreadTTLConfig class to set default TTL (in minutes), sweep interval, and expiry strategy ("delete") for automatic cleanup of thread checkpoints.
• ›Supports passing checkpointer configuration to Docker environments via the LANGGRAPH_CHECKPOINTER environment variable automatically.
• ›Switches from msgpack to ormsgpack for improved serialization performance.

LangGraph CLI dev command gains --allow-blocking flag to suppress synchronous I/O blocking errors

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

$ langgraph dev --allow-blocking

• ›Adds --allow-blocking flag to the dev command, allowing the server to run without raising errors when synchronous I/O blocking operations are detected.

Letta 0.7.1 adds a database Docker Compose file and reasoning token support for Gemini Flash.

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

• ›Adds a database Docker Compose file for easier local database setup.
• ›Enables reasoning tokens when using Gemini Flash as the backing model.
• ›Improves conversation search message filtering to work correctly with SQLite3.

AutoGen v0.5.4 adds AgentTool/TeamTool nesting, Azure AI Agent adapter, Docker Jupyter executor, and Canvas shared memory.

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

writer_tool = AgentTool(agent=writer)
assistant = AssistantAgent(
    name="assistant",
    model_client=model_client,
    tools=[writer_tool],
    system_message="You are a helpful assistant.",
)

from autogen_agentchat.agents import CodeExecutorAgent

executor_agent = CodeExecutorAgent(
    name="coder",
    code_executor=executor,
    max_retries_on_error=3,
)

• ›Adds AgentTool and TeamTool to wrap agents and teams as callable tools for other agents, enabling nested agent hierarchies.
• ›Introduces AzureAIAgent adapter with support for file search, code interpreter, and Azure AI Agent service integration.
• ›Adds DockerJupyterCodeExecutor for sandboxed Jupyter code execution inside Docker containers.
• ›Introduces experimental CanvasMemory — a shared whiteboard memory letting multiple agents collaboratively read/write a common artifact.
• ›Adds autogen-contextplus community extension for advanced model context management with automatic summarization and truncation.

AutoGen 0.5.3 adds code generation to CodeExecutorAgent, serializable AssistantAgent, MCP shared sessions, and team event controls.

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

from autogen_agentchat.agents import CodeExecutorAgent

# model_client enables code generation; executor runs the result
agent = CodeExecutorAgent(
    name="coder",
    code_executor=executor,
    model_client=model_client,
)
result = await agent.run(task="Write and run a Python script that prints the first 10 Fibonacci numbers.")

from autogen_agentchat.teams import SelectorGroupChat

team = SelectorGroupChat(
    participants=[agent1, agent2],
    model_client=model_client,
    emit_team_events=True,   # set False to hide SelectorSpeakerEvent etc.
)
async for msg in team.run_stream(task="Analyze this dataset."):
    print(msg)

• ›Enables CodeExecutorAgent to generate and execute code in the same invocation via new code generation support.
• ›Adds autogen_core.utils module with JSON schema utilities, enabling AssistantAgent to be serialized when output_content_type is set.
• ›Introduces optional emit_team_events parameter on teams to control whether events like SelectorSpeakerEvent are emitted through run_stream.
• ›Allows mcp_server_tools factory to reuse a shared MCP session, enabling patterns like a persistent Playwright MCP server connection.
• ›Adds message type printing to the Console output.

AutoGen v0.5.2 adds Gemini 2.5 Pro support and exposes more Task-Centric Memory parameters and TypedDict classes.

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

• ›Adds Gemini 2.5 Pro Preview as a supported model.
• ›Exposes additional Task-Centric Memory (TCM) configuration parameters for finer control over memory behavior.
• ›Exposes TCM TypedDict classes so applications can directly reference and type-check Task-Centric Memory structures.
• ›Adds PowerShell path detection to the code executor for Windows environments.

AutoGen v0.5.1 adds structured output, Azure AI Search tool, token-limited context, and richer model client capabilities.

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

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.messages import TextMessage
from autogen_agentchat.ui import Console
from autogen_core import CancellationToken
from autogen_core.tools import FunctionTool
from autogen_ext.models.openai import OpenAIChatCompletionClient
from pydantic import BaseModel
from typing import Literal

class AgentResponse(BaseModel):
    thoughts: str
    response: Literal["happy", "sad", "neutral"]

def sentiment_analysis(text: str) -> str:
    return "happy" if "happy" in text else "sad" if "sad" in text else "neutral"

tool = FunctionTool(sentiment_analysis, description="Sentiment Analysis", strict=True)
model_client = OpenAIChatCompletionClient(model="gpt-4o-mini")
agent = AssistantAgent(
    name="assistant",
    model_client=model_client,
    tools=[tool],
    system_message="Use the tool to analyze sentiment.",
    output_content_type=AgentResponse,
)
await Console(agent.on_messages_stream(
    [TextMessage(content="I am happy today!", source="user")], CancellationToken()
))

• ›Introduces StructuredMessage[T] generic message type, enabling custom application-defined message types in AgentChat.
• ›Adds output_content_type parameter to AssistantAgent so agents can emit structured Pydantic model responses via StructuredMessage.
• ›New AzureAISearchTool integration lets agents perform semantic/keyword search against Azure AI Search indexes.
• ›Adds candidate_func parameter to SelectorGroupChat for filtering the pool of agent candidates before selection.
• ›Adds async support for selector_func and candidate_func in SelectorGroupChat.

OpenAI Agents SDK v0.0.13 adds extra_headers to ModelSettings, streaming cancellation, and to_json_dict serialization.

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

from agents import ModelSettings

settings = ModelSettings(
    model="gpt-4o",
    extra_headers={"X-Custom-Header": "my-value", "X-Team-ID": "team-42"}
)

from agents import ModelSettings

settings = ModelSettings(model="gpt-4o", temperature=0.7)
print(settings.to_json_dict())

• ›Adds extra_headers parameter to ModelSettings to pass custom HTTP headers on a per-model-settings basis.
• ›Adds to_json_dict() method to ModelSettings for serializing model configuration to a JSON-compatible dictionary.
• ›Enables cancellation of in-progress streaming runs via the streaming result object.

OpenAI Agents SDK v0.0.12 adds LiteLLM integration for any third-party model and lifts strict-mode restrictions on agent output types.

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

from agents import Agent

agent = Agent(
    name="claude-agent",
    model="litellm/anthropic/claude-3-5-sonnet-20240620",
    instructions="You are a helpful assistant.",
)

• ›Adds LiteLLM integration: pass any provider model to Agent via model="litellm/<provider>/<model_name>" (e.g. model="litellm/anthropic/claude-3-5-sonnet-20240620") to route completions through LiteLLM's unified interface.
• ›Enables non-strict output types on Agent, allowing more complex structured outputs that previously required strict JSON schema mode.

OpenAI Agents SDK v0.0.10 adds previous_response_id support and new ModelSettings fields extra_query, extra_body, and stream_options.

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

from agents import ModelSettings

settings = ModelSettings(
    extra_query={'my-param': 'value'},
    extra_body={'custom_field': True}
)

• ›Adds extra_query and extra_body fields to ModelSettings for passing extra request parameters directly to the underlying API call.
• ›Adds support for previous_response_id from the OpenAI Responses API, enabling stateful multi-turn conversations without re-sending full message history.
• ›Adds overwrite mechanism for stream_options in ModelSettings, allowing fine-grained control over streaming behavior.

OpenAI Agents SDK v0.0.8 adds store, metadata, and reasoning to ModelSettings, plus Databricks MLflow tracing and MCP strict-schema conversion.

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

from agents import Agent, ModelSettings

agent = Agent(
    name="analyst",
    model="o3",
    model_settings=ModelSettings(
        store=True,
        reasoning={"effort": "high"},
        metadata={"session": "pentest-42", "owner": "red-team"}
    )
)

• ›Adds store parameter to ModelSettings to control whether model responses are stored.
• ›Adds metadata field to ModelSettings for attaching arbitrary key-value metadata to model requests.
• ›Adds reasoning parameter to ModelSettings to configure model reasoning behavior.
• ›Converts MCP tool schemas to strict mode where possible, improving compatibility with strict-schema model APIs.
• ›Adds Databricks MLflow tracing integration for agent observability.

PydanticAI v0.1.7 adds Gemini video support, multi-instruction agents, and attribute docstrings on tools by default.

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

• ›Sets use_attribute_docstrings=True as the default on tools, so attribute-level docstrings are automatically used in tool schemas without explicit configuration.
• ›Supports multiple instructions on an Agent, with correct concatenation when more than one instruction is provided.
• ›Adds Gemini video support, enabling video content to be passed to Gemini models via the PydanticAI message API.

PydanticAI v0.1.6 adds OpenTelemetry tracing for AudioUrl, VideoUrl, DocumentUrl, and ImageUrl content.

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

• ›OpenTelemetry spans now include AudioUrl, VideoUrl, DocumentUrl, and ImageUrl content metadata, enabling full observability over multimodal model interactions.

PydanticAI v0.1.4 adds MCP logging, o3/o4-mini support, and OpenAI document input types.

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

from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIModel

agent = Agent(OpenAIModel('o3'))
# or
agent = Agent(OpenAIModel('o4-mini'))

• ›Supports DocumentUrl and BinaryContent document types for OpenAI provider inputs.
• ›Adds support for OpenAI o3 and o4-mini models.
• ›Supports MCP logging and raises minimum MCP version requirement to 1.6.0.
• ›Makes agent and graph runs serializable, enabling persistence and resumption of run state.

PydanticAI v0.1.3 adds extra_body to ModelSettings, OpenTelemetry instruction spans, and Gemini 2.5 Flash support.

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

from pydantic_ai import Agent
from pydantic_ai.settings import ModelSettings

agent = Agent(
    'openai:gpt-4o',
    model_settings=ModelSettings(extra_body={'reasoning_effort': 'high'})
)
result = agent.run_sync('Explain quantum entanglement.')
print(result.data)

• ›Adds extra_body field to ModelSettings for passing arbitrary additional body parameters to model API requests.
• ›Adds OpenTelemetry span events for instructions, making instruction content visible in traces.
• ›Adds support for the gemini-2.5-flash-preview-04-17 model.

PydanticAI v0.1.2 exposes StdioServerParameters.cwd for controlling MCP server working directories.

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

StdioServerParameters(command='npx', args=['-y', 'my-mcp-server'], cwd='/path/to/project')

• ›Exposes StdioServerParameters.cwd parameter, allowing callers to set the working directory for stdio MCP server processes.

PydanticAI v0.1.0 renames result→output, adds VideoUrl for Bedrock, spans on run results, and an instructions parameter.

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

result = await agent.run('Classify this alert.')
for span in result.spans:
    print(span.name, span.start_time)

• ›Adds VideoUrl input support to BedrockConverseModel for passing video content to the Bedrock Converse API.
• ›Adds additional configuration fields to BedrockConverseModel for the Bedrock Runtime API.
• ›Adds instructions parameter to agents for supplying system-level instructions at call time.
• ›Exposes spans as an attribute on agent/graph runs and run results for OpenTelemetry trace access.
• ›Adds support for gemini-2.5-pro-preview-03-25 (paid tier of Gemini 2.5 Pro).

PydanticAI v0.0.55 allows empty user prompts in streaming runs and adds a PydanticAI User-Agent header to outbound requests.

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

• ›Adds a PydanticAI User-Agent header to all outbound HTTP requests, enabling easier identification of traffic in server logs and API dashboards.
• ›Supports empty user_prompt values in run_stream, allowing streaming runs to be initiated with no user message.

PydanticAI v0.0.54 adds stop_sequences to ModelSettings, optional user_prompt, and yields the initial graph node during iteration.

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

from pydantic_ai import Agent
from pydantic_ai.settings import ModelSettings

agent = Agent(
    'openai:gpt-4o',
    model_settings=ModelSettings(stop_sequences=['---END---']),
)
result = await agent.run('Summarize this document.')
print(result.output)

• ›Adds stop_sequences field to ModelSettings to control where model output is terminated.
• ›Makes user_prompt optional, allowing agent invocations without a required user-facing prompt.
• ›Graph (and therefore Agent) iteration now yields the initial node, giving callers visibility into the full execution sequence from the start.

PydanticAI v0.0.53 adds OpenAI strict mode support for structured output.

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

• ›Adds OpenAI strict mode support, enabling stricter schema enforcement when using OpenAI models for structured output generation.

PydanticAI v0.0.52 adds dependency injection support to the evals framework.

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

• ›Enables passing dependencies into evals, bringing PydanticAI's dependency-injection model to the evaluation framework.

PydanticAI v0.0.51 switches mcp-run-python to Deno and aligns OpenAI model strictness.

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

• ›Switches the mcp-run-python server runtime from its previous backend to Deno.
• ›Matches OpenAI models in strictness, aligning structured-output enforcement with OpenAI's strict mode behavior.

PydanticAI v0.0.49 adds Gemini 2.5 Pro, OpenAI built-in tools, and new OpenAIResponsesModelSettings fields

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

from pydantic_ai.models.openai import OpenAIResponsesModelSettings

settings = OpenAIResponsesModelSettings(
    generate_summary=True,
    truncation='auto'
)

• ›Adds generate_summary and truncation fields to OpenAIResponsesModelSettings for controlling response summarization and context truncation.
• ›Adds OpenAI built-in tools support, exposing OpenAI-native tool integrations through the PydanticAI interface.
• ›Adds Gemini 2.5 Pro model support alongside CLI improvements.
• ›Anthropic models now pass ImageUrl and DocumentUrl references directly without downloading content, enabling more efficient media handling.

Semantic Kernel Python 1.29.0 adds Brave search, kernel cloning, process state management, and richer agent polling and metadata.

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

from semantic_kernel import Kernel

original_kernel = Kernel()
# ... register plugins, services, etc.
cloned_kernel = original_kernel.clone()
cloned_kernel.add_plugin(extra_plugin)

• ›Adds RunPollingOptions at the run-level for AzureAIAgent, OpenAIAssistantAgent, and OpenAIResponsesAgent, and moves RunPollingOptions import to base level alongside continue during invoke tool calls support.
• ›Returns thread_id and run_id in agent response metadata, giving callers direct access to run identifiers from agent invocations.
• ›Adds Brave search capability as a new plugin/connector in the Python SDK.
• ›Adds kernel.clone() (clone a kernel) to programmatically duplicate a configured Kernel instance.
• ›Adds Process State Management support for stateful multi-step process workflows.

Semantic Kernel .NET 1.47.0 adds SK-agent-as-MCP-tool exposure, MCP tool consumption by agents, Brave search, and .yml prompt support.

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

var braveConnector = new BraveConnector(apiKey: "<your-brave-api-key>");
var webSearchPlugin = new WebSearchEnginePlugin(braveConnector);
kernel.ImportPluginFromObject(webSearchPlugin, "WebSearch");

• ›Adds BraveConnector to WebSearchPlugin, enabling Brave Search as a web search backend alongside existing providers.
• ›Enables SK agents to be exposed as MCP tools (SK agent as MCP tool), letting other MCP clients call Semantic Kernel agents via the Model Context Protocol.
• ›Enables SK agents to consume MCP tools (Use Mcp tools by SK agents), so agents can invoke any MCP-compatible tool server.
• ›Adds support for .yml file extensions (in addition to .yaml) when loading prompt templates in the C# SDK.
• ›Adds support for relative file references in Prompty prompt files, allowing prompts to reference other assets by relative path.

Semantic Kernel Python 1.28.1 expands MCP integration with prompt, sampling, and agent-as-server support.

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

• ›Adds MCP prompt and sampling support to Semantic Kernel's MCP integration.
• ›Enables creating an MCP server directly from a Semantic Kernel agent.

Semantic Kernel dotnet-1.46.0 adds declarative agents, exposes kernel function metadata, and graduates stable APIs from experimental.

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

• ›Adds declarative agents support via the new Feature declarative agents capability, enabling agent definitions without imperative code.
• ›Exposes the underlying MethodInfo from KernelFunction, giving callers direct access to the reflected method for inspection or invocation.
• ›Removes [Experimental] flags from previously preview APIs, promoting them to stable surface in the public contract.
• ›Adds a React sample app demonstrating SK Process Cloud Events integration.
• ›Adds samples for MCP Resources and Resource Templates, showing how to surface and consume typed resource endpoints from an MCP server.

Semantic Kernel Python 1.28.0 adds MCP Server support, Auto Function Invocation Filters for agents, and multimodal Kernel Functions from Prompt.

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

• ›Exposes Semantic Kernel as a Model Context Protocol (MCP) Server, letting external MCP clients invoke SK kernel functions directly.
• ›Adds Auto Function Invocation Filter support for AzureAIAgent and OpenAIAssistantAgent, enabling pre/post-invocation hooks on auto-called functions.
• ›Enables KernelFunction creation from prompts that include image and audio content, extending multimodal support to prompt-based function definitions.
• ›Adds a sample demonstrating the GitHub MCP Server integrated with AzureAIAgent as a practical MCP + agent usage pattern.
• ›Allows Semantic Kernel settings objects to be instantiated directly without requiring environment-variable or file-based configuration.

Semantic Kernel Python 1.27.0 adds Agents-as-Kernel-Functions, an OpenAI Responses Agent, SQL Connector, and MCP server plugin support.

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

async def handle_intermediate(message):
    print(f'Intermediate: {message}')

async for response in agent.invoke(
    thread=thread,
    on_intermediate_message=handle_intermediate,
):
    print(response)

• ›Adds on_intermediate_message callback to the Agent abstraction, enabling callers to receive streamed intermediate messages during agent invocation.
• ›Introduces the OpenAIResponsesAgent class, a new agent type backed by the OpenAI Responses API.
• ›Supports using an MCP (Model Context Protocol) server as a Semantic Kernel plugin, allowing MCP-exposed tools to be called as kernel functions.
• ›Introduces the SQL Connector, enabling vector store and data retrieval operations against SQL databases.
• ›Allows Agents to be used directly as Kernel Functions, composing agent invocations inside kernel pipelines.

Semantic Kernel .NET 1.45.0 adds audio I/O for OpenAI, Tavily integration, MCP samples, and agent API improvements.

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

• ›Adds OnIntermediateMessage callback (renamed from OnNewMessage) to receive notifications for all agent messages during invocation.
• ›Adds audio input and output support for OpenAI chat completions.
• ›Adds Tavily search integration as a new plugin/connector.
• ›Adds ChatHistoryAgent (marked experimental) as a new agent type.
• ›Adds agent-specific parameters support via new overloads in the common agent invoke API.

camel-ai v0.2.47 adds OceanBase DB integration, Jina reranker, Alibaba Tongxiao Search, ScrapeGraph SDK, and O4-mini/O3 model support.

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

• ›Adds support for O4-mini and O3 models.
• ›Integrates OceanBase database as a new storage/retrieval backend.
• ›Adds a Jina reranker toolkit for reranking retrieval results.
• ›Adds Alibaba Tongxiao Search API support via search_toolkit.
• ›Integrates scrapegraph-sdk for AI-powered web scraping.

camel-ai v0.2.46 adds PyAutoGUI toolkit, LM Studio integration, and refreshed AWS Bedrock and OpenAICompatibleModel support.

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

• ›Adds PyAutoGUI toolkit, enabling agents to drive desktop GUI automation through the new pyautogui toolkit interface.
• ›Adds LM Studio integration via LMStudioModel, letting practitioners run locally-hosted LM Studio models as a camel-ai backend.
• ›Updates AWS Bedrock integration with refreshed model support through aws_bedrock.
• ›Enhances OpenAICompatibleModel so all model implementations inherit from it, simplifying custom model integration.
• ›Refactors the video toolkit with expanded capabilities for video processing workflows.

camel-ai v0.2.45 adds Ubuntu Docker runtime and OpenAI GPT-4.1 model support

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

• ›Supports OpenAI gpt-4.1 as a model backend option.
• ›Adds Ubuntu Docker runtime for sandboxed code execution environments.
• ›Adds timeout setting for all model backends to cap inference wait time.

camel-ai v0.2.43 adds Exa search, crawl4ai, Google Calendar toolkit, Together/Azure embeddings, PPIO LLM, and Llama 4 via OpenRouter.

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

• ›Adds Exa search integration as a new toolkit for web search capabilities.
• ›Integrates crawl4ai for AI-powered web crawling support.
• ›Adds GoogleCalendarToolkit for interacting with Google Calendar from agents.
• ›Adds Together embedding support as a new embedding backend.
• ›Adds Azure embedding support as a new embedding backend.

camel-ai v0.2.42 adds dict-of-strings input to the step function and enhances the terminal toolkit.

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

• ›Allows a dict of strings to be passed as input to the step function, enabling richer structured message passing to agents.
• ›Enhances the terminal toolkit with new capabilities for agent-driven shell interactions.

camel-ai v0.2.40 adds ModelScope integration, YAML/JSON model config loading, MCP server support, and new data-generation verifiers

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

from camel.toolkits import HumanToolkit

toolkit = HumanToolkit()
toolkit.send_message_to_user('Task complete — results saved to output.csv')

• ›Supports loading model configs from YAML and JSON files via SaranshPandya's implementation, enabling file-driven model configuration.
• ›Adds send_message_to_user method to human_toolkit for direct user messaging from agent workflows.
• ›Allows optional output dimension parameter in OpenAI-compatible embedding calls.
• ›Integrates ModelScope models as a new model provider in camel.
• ›Adds a self-instruct data generator for synthetic instruction dataset creation.

HolmesGPT 0.10.8 adds custom Prometheus label support, streaming analysis, configurable Prometheus healthchecks, and improved ArgoCD and Coralogix toolsets.

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

• ›Adds configurable Prometheus healthcheck support, allowing control over how Holmes validates Prometheus connectivity.
• ›Adds support for custom labels in Prometheus queries, enabling more targeted metric lookups.
• ›Adds streaming analysis output, delivering investigation results incrementally rather than waiting for full completion.
• ›Improves the ArgoCD toolset with enhanced integrations for application state analysis.
• ›Improves the Coralogix toolset to return source URLs alongside log results, making it easier to pivot directly to Coralogix.

smolagents v1.13.0 adds agent interruption, image observation logging in the Gradio UI, and automatic submodule import authorization.

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

from smolagents import ToolCollection

tools = ToolCollection.from_mcp("<mcp_server_url>", trust_remote_code=True)

from smolagents import CodeAgent, HfApiModel

agent = CodeAgent(
    tools=[],
    model=HfApiModel(),
    additional_authorized_imports=["numpy"],  # numpy.random, numpy.linalg, etc. are now also authorized
)

• ›Adds trust_remote_code parameter to ToolCollection.from_mcp for controlling remote code trust when loading MCP tool collections.
• ›Authorizes submodule imports automatically when a top-level package is listed in additional_authorized_imports — e.g. additional_authorized_imports=["numpy"] now also permits numpy.random and other subpackages without listing each one explicitly.
• ›Adds agent interruption support, allowing a running agent to be interrupted mid-execution.
• ›Gradio UI now logs images observed by the agent during a run, making multimodal agent traces visible in the interface.
• ›Exposes the underlying Gradio app object so users can retrieve and customize it directly.

Aider v0.81.0 adds Quasar Alpha model support and OpenRouter OAuth authentication flow.

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

$ aider --model quasar

• ›Adds support for openrouter/openrouter/quasar-alpha model (currently free on OpenRouter), accessible via aider --model quasar.
• ›Offers OpenRouter OAuth authentication automatically when an OpenRouter model is specified but no API key is present.
• ›Adds model metadata for openrouter/google/gemini-2.0-flash-exp:free.
• ›Configures gemini/gemini-2.0-flash and openrouter/google/gemini-2.0-flash-exp:free as weak models for Gemini 2.5 Pro models.

Cline v3.13.2 adds Gemini 2.5 Flash, prompt caching, thinking budgets, and browser use for any image-capable model.

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

$ # .clineignore
!include .clineignore-shared
!include .clineignore-secrets

• ›Adds Gemini 2.5 Flash model support to both Vertex AI and Gemini providers.
• ›Adds prompt caching support to the Gemini provider.
• ›Adds thinking budget configuration for Gemini models.
• ›Supports !include .file directive in .clineignore for composable ignore rules.
• ›Enables browser use through any model that supports images, removing the prior supportsComputerUse restriction.

Cline v3.13.0 adds rules management, slash commands, message editing, and new model support including OpenAI o3 and Azure DeepSeek.

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

• ›Adds a Cline rules popover under the chat field for adding, enabling, and disabling workspace-level or global rule files.
• ›Adds a slash command menu (type "/") for quick actions such as creating new tasks.
• ›Adds ability to edit past messages with options to restore the workspace back to that point in history.
• ›Allows sending a custom message when selecting an option provided by the question or plan tool.
• ›Adds a command to jump directly to Cline's chat input.

Cline v3.12.3 adds out-of-workspace tool indicators, global rules files, a Mermaid copy button, and a CLI for automated evals.

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

• ›Adds visual indicators when Cline tools operate on files or paths outside the current workspace.
• ›Supports fetching global Cline rules files, enabling shared rule sets beyond project-level configuration.
• ›Adds a copy-code button to Mermaid diagram previews for quick extraction of diagram source.
• ›New CLI for orchestrating automated evaluations of Cline agents.

Cline v3.12.2 adds GPT-4.1 as a supported model.

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

• ›Adds GPT-4.1 as a supported model option.

Cline v3.12.1 adds a visual checkpoint indicator and improved context management.

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

• ›Adds a visual checkpoint indicator to clearly show when checkpoints are created during a session.
• ›Introduces improved context management for more effective handling of conversation context.

Cline v3.12.0 adds model favorites, out-of-workspace auto-approve, Grok 3 Mini streaming, and MCP settings shortcut.

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

• ›Adds favorite toggles for models when using the Cline & OpenRouter providers, making it faster to pin preferred models.
• ›New auto-approve options for file edits and reads outside of the workspace.
• ›Adds an indicator showing the number of diff edits when Cline edits a file.
• ›Adds streaming support and a reasoning effort option for xAI's Grok 3 Mini.
• ›Adds a settings button to the MCP popover for quick access to modify installed servers.

Cline v3.11.0 adds redesigned checkpoints with visual indicators and support for xAI Grok 3 models.

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

• ›Redesigned Checkpoints: checkpoints are created more frequently during tasks and appear as line indicators on the left edge of chat, with hover-to-expand details including creation time.
• ›Adds support for xAI's Grok 3 models as a provider option.

Cline v3.10.1 adds a 'Create New Task' autonomous tool and a CMD+' shortcut for quickly adding selected text.

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

• ›New 'Create New Task' tool lets Cline autonomously spin up a new task without user initiation.
• ›Adds CMD+' keyboard shortcut to send selected text directly to Cline.
• ›Auto-focuses the text input field when the 'Add to Cline' shortcut is triggered.

Cline v3.10.0 adds local Chrome browser integration, smarter context shortening, and an all-commands auto-approve option.

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

• ›Enables session-based browsing using your local Chrome browser, preserving actual browser state for debugging and productivity workflows.
• ›Adds an in-chat modal for quickly enabling or disabling MCP servers without leaving the chat area.
• ›New auto-approve option to approve ALL commands, bypassing per-command confirmation prompts.
• ›Smarter context window shortening now removes old file contents from conversation history instead of truncating the first half of messages, preserving narrative integrity.
• ›Supports drag-and-drop of files and folders directly into the Cline chat input.

Cline v3.9.2 adds manual-edit detection, smarter file mention search, and Bytedance Doubao support.

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

• ›Detects when users manually edit files so Cline automatically re-reads them, reducing diff edit errors.
• ›Adds relevance-based scoring and filtering to file mention search results for faster, more accurate lookups.
• ›Supports Bytedance Doubao as a new model provider.
• ›Adds recommended model suggestions for the Cline provider.

Cline v3.9.0 adds extended thinking for LiteLLM and a dedicated local MCP Server configuration tab.

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

• ›Enables extended thinking mode for the LiteLLM provider.
• ›Adds a dedicated tab for configuring local MCP Servers.

Cline v3.8.6 adds a UI for connecting remote servers and a new Mentions Feature Guide.

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

• ›Adds UI for adding and managing remote servers directly from the interface.
• ›Adds Mentions Feature Guide with updated related documentation.

Cline v3.8.5 adds remote MCP Server support via SSE, Gemini 2.5 Pro on Vertex AI, and new UI controls for MCP management.

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

• ›Supports remote MCP Servers using Server-Sent Events (SSE) transport.
• ›Adds gemini-2.5-pro-exp-03-25 model to the Vertex AI provider.
• ›Adds history, MCP, and new task buttons to the popout view.
• ›Adds thumbs up/down task feedback telemetry on task completion.
• ›Adds a toggle to disable individual remote MCP servers.

Continue v1.0.6 adds Docker model runner, Inception/InceptionLabs providers, LS/Grep/Glob agent tools, prompt blocks, and Bedrock prompt caching.

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

• ›Adds support for the Docker model runner as a model provider.
• ›Adds the inception provider for Inception Labs models.
• ›Adds the inceptionlabs provider as a dedicated InceptionLabs integration.
• ›Adds LS (list directory), Grep, and Glob built-in agent tools for file-system navigation during agentic sessions.
• ›Adds prompt blocks feature (feat: prompt blocks), enabling reusable prompt components in assistant configurations.

Goose v1.0.20 adds session removal, a GUI deeplink extension warning, and a bumped tool limit with updated alerts.

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

• ›Adds ability to remove sessions via new 'remove session' capacity.
• ›Adds GUI warning when installing an extension from a deeplink.
• ›Bumps tool limit and updates associated alerts.

Goose v1.0.19 adds o4-mini and GPT-4.1 support, persistent CLI themes, custom OpenAI headers, and an FFI for the Rust library.

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

• ›Adds support for the o4-mini model.
• ›Adds per-model prompts for better GPT-4.1 support.
• ›Supports OPENAI_CUSTOM_HEADERS being set in the Goose config file.
• ›Builds a prototype FFI for the Goose Rust library, enabling external language bindings.
• ›GOOSE_CLI_THEME now persists to the config file and applies to future sessions automatically.

Goose v1.0.18 adds tool-level permission control, recipes/custom agents, SSE extensions, file-based secrets, and GCP Vertex AI support.

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

$ GOOSE_TEMPERATURE=0.2 goose session

$ ANTHROPIC_HOST=https://my-anthropic-proxy.internal goose session

• ›Adds tool-level permission control in both CLI and UI, letting practitioners approve or deny individual tools before execution.
• ›Introduces recipes — custom Goose agent configurations that can be shared via URL deeplinks.
• ›Adds a recipe editor UI for building and sharing custom agent configurations.
• ›Supports SSE (Server-Sent Events) extensions via scheme URI, enabling remote extension connectivity.
• ›Adds support for generic GCP Vertex AI Claude and Gemini models as a provider.

Goose v1.0.17 adds session sharing, chat search, prompt library, VSCode server support, and input/output token tracking.

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

• ›Adds session sharing from the UI, with pre-configuration via GOOSE_BASE_URL_SHARE environment variable and additional metadata in the shared session view.
• ›Adds search functionality to the chat view.
• ›Adds a Prompt Library to the UI.
• ›Adds the VSCode server to the extensions list.
• ›Adds input and output token tracking to SessionMetadata.

OpenHands 0.34 adds a Changes tab for reviewing agent modifications, custom sandboxes for the resolver, and tool disabling controls.

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

• ›New Changes tab in the UI surfaces all file modifications made by OpenHands during a session, making agent-driven diffs reviewable at a glance.
• ›Adds ability to disable specific default tools, giving operators fine-grained control over which capabilities the agent can invoke.
• ›Supports custom sandbox images for the resolver, enabling reproducible, project-specific environments when resolving GitHub issues.
• ›Resolver now names branches with the openhands/ prefix, establishing a consistent convention for identifying agent-created branches.
• ›Updated home screen layout improves navigation and workspace entry points.

OpenHands 0.33 adds native MCP server support, GitLab OAuth/PAT integration, GitHub Enterprise resolver, and interactive CLI commands.

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

• ›Supports MCP servers natively via CodeActAgent, enabling model context protocol tool use within agents.
• ›Adds GitLab API integration with both OAuth and PAT token authentication.
• ›Enables PR type specification when using the GitHub Action resolver.
• ›Supports GitHub Enterprise and on-premises GitLab in the GitHub Action resolver.
• ›Adds interactive CLI commands /init, /help, and /exit with an enhanced startup experience.

OpenHands 0.32 adds microagent context visibility, PR template awareness, and enables context condensation by default.

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

• ›Displays microagent context directly in the UI so practitioners can see which microagent knowledge is active during a session.
• ›Shows edited file paths in the conversation headline for at-a-glance change tracking.
• ›Enables context condensation by default, automatically compressing long conversation histories to stay within model context limits.
• ›Expands GitLab repository listing to include repos where the user has membership but is not the owner.
• ›Supports microagent files without a required header, reducing friction when authoring custom microagents.

OpenHands 0.31.0 adds vision-based browsing with PDF/image support, OpenHands LM integration, and multi-provider Git configuration.

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

• ›Enables vision-based browsing by default, allowing OpenHands to see and interpret PDFs and images rendered in the browser.
• ›Adds support for OpenHands LM as a new LLM provider option.
• ›Supports configuring multiple Git providers simultaneously (e.g., GitHub + GitLab) in local OpenHands deployments.
• ›Generates LLM-based natural-language titles for conversations automatically.

Zed v0.183.12 adds Ollama support for Qwen3 models with 16K token context.

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

• ›Adds Ollama support for Qwen3 models, defaulting to a 16K token context window (configurable via Assistant Configuration).

Zed v0.183.10 adds Git amend, customizable bottom dock layouts, OpenAI o3/o4-mini support, and new editor actions.

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

{
  "bottom_dock_layout": "full"
}

{
  "bottom_dock_layout": "left_aligned"
}

• ›Adds bottom_dock_layout setting with options contained (default), full, left_aligned, and right_aligned to control how the bottom dock is laid out when multiple docks are open simultaneously.
• ›Adds new actions editor::FindNextMatch and editor::FindPreviousMatch that jump to the first or last selection when multiple selections exist, similar to editor::SelectNext/editor::SelectPrevious with 'replace_newest': true.
• ›Adds Git amend support in the Git panel.
• ›Adds support for OpenAI o3 and o4-mini models via the OpenAI API and Copilot Chat providers.
• ›Tasks are now loaded from local .vscode/tasks.json files even when they are .gitignored.

Zed v0.182.11 adds support for OpenAI o3 and o4-mini models via OpenAI API and Copilot Chat providers.

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

• ›Adds support for OpenAI o3 and o4-mini models via the OpenAI API and Copilot Chat providers.

Zed v0.182.9 adds screensharing on X11, --user-data-dir CLI flag, task tags, LSP stop control, and new completions.lsp_insert_mode setting.

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

$ zed --user-data-dir /tmp/zed-profile-test .

• ›Adds --user-data-dir CLI flag to specify a custom user data directory.
• ›Adds completions.lsp_insert_mode setting to control what is replaced when an LSP completion is accepted.
• ›Adds ConfirmCompletionInsert and ConfirmCompletionReplace actions for fine-grained LSP completion insertion control; shift-enter triggers ConfirmCompletionReplace by default, overriding completions.lsp_insert_mode.
• ›Adds support for the insert_text_mode field of completions from the Language Server Protocol.
• ›Adds an editor: toggle case command, bound to cmd-shift-u (macOS) and ctrl-shift-u (Linux) in the JetBrains keymap.

Zed v0.181.7 adds Gemini 2.5 Pro and GPT-4.1 family models to Copilot Chat and the Agent panel.

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

• ›Adds Gemini 2.5 Pro to Copilot Chat, available in both the stable Assistant panel and the new Agent panel (beta).
• ›Adds OpenAI GPT-4.1, GPT-4.1 mini, and GPT-4.1 nano via Copilot Chat and the OpenAI API, available in both the stable Assistant panel and the new Agent panel (beta).

Zed v0.181.6 restores screen sharing support on X11.

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

• ›Re-adds screen sharing support on X11.

Zed v0.181.5 adds GPU selection on Linux, git commit viewer, Vim :ls/:options/g?, DeepSeek R1 on Bedrock, and project panel gitignore hiding.

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

hide_mouse: on_typing

• ›Adds ZED_DEVICE_ID environment variable on Linux to force Zed to use a specific GPU (hex value, e.g. ZED_DEVICE_ID=0x2484); obtain the ID via lspci -nn | grep VGA.
• ›Adds ProjectPanel::ToggleHideGitIgnore action and project_panel.hide_gitignore setting to hide gitignored files in the project panel.
• ›Adds hide_mouse setting accepting values on_typing_and_movement, on_typing, or never to control mouse cursor auto-hiding behavior.
• ›Adds support for Terminal && vi_mode as a keybinding context to detect when the terminal is in vi mode.
• ›Vim: adds :ls and :buffers commands.

Zed v0.180.2 adds fold persistence, LSP env vars, go_to_definition_fallback, --system-specs, and Gemini 2.5 Pro support.

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

{
  "lsp": {
    "rust-analyzer": {
      "binary": {
        "path": "/usr/local/bin/rust-analyzer",
        "env": {
          "RA_PROFILE": "*>100"
        }
      }
    }
  }
}

{
  "go_to_definition_fallback": "none"
}

$ zed --system-specs

• ›Adds editor::CopyAndTrim action to trim whitespace from selections when copying.
• ›Adds go_to_definition_fallback setting, accepting find_all_references (default) or none, to control fallback behavior when go-to-definition finds no results.
• ›Adds env key under lsp.<server>.binary in settings to set environment variables for any language server (e.g. {"lsp": {"rust-analyzer": {"binary": {"env": {"RA_PROFILE": "*>100"}}}}}).
• ›Adds --system-specs flag to the Zed binary to retrieve system specs for GitHub issue reports without opening the GUI.
• ›Adds persistence for editor folds so they are preserved across restarts.

KoboldCpp v1.89 adds NoScript chat/image gen, new --overridekv/--overridetensors flags, and Vulkan coopmat2 support.

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

$ koboldcpp.exe --model mymodel.gguf --overridekv llama.context_length=uint32:8192

$ koboldcpp.exe --model mymodel.gguf --overridetensors output=CPU

• ›Adds --overridekv launcher flag to overwrite a single model metadata property at runtime; input format is keyname=type:value.
• ›Adds --overridetensors launcher flag to place tensors matching a pattern onto a specific backend; input format is tensornamepattern=buffertype.
• ›Enables Vulkan coopmat2 (CM2) support for Nvidia GPUs with Game Ready Driver 576.02 or later, adding flash attention and overall speed improvements; OldCPU Vulkan binaries now exclude coopmat, coopmat2, and DP4A.
• ›Improved NoScript mode at /noscript now supports chat mode and image generation without JavaScript, compatible with browsers as old as Internet Explorer 5 and Netscape Navigator 4.
• ›Enables Image Generation LoRAs for use with quantized diffusion models (LoRA itself should remain unquantized).

KoboldCpp v1.88 adds image inpainting, a JSON-to-GBNF grammar endpoint, --maxrequestsize flag, and Llama 4 model support.

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

$ koboldcpp.exe --model mymodel.gguf --maxrequestsize 67108864

$ curl -X POST http://localhost:5001/api/extra/json_to_grammar -H 'Content-Type: application/json' -d '{"type":"object","properties":{"name":{"type":"string"},"age":{"type":"integer"}},"required":["name","age"]}'

• ›Adds --maxrequestsize flag to configure the server's maximum HTTP request payload size before dropping a request (default: 32 MB).
• ›Adds new API endpoint POST /api/extra/json_to_grammar to convert a JSON schema into GBNF grammar.
• ›Adds Image Inpainting support to StableUI, including a masking UI for Img2Img editing (similar to A1111) with updated API docs.
• ›Adds a clip-skip slider to StableUI.
• ›Adds Zenity and YAD support for native file picker dialogs on Linux; falls back to the previous TKinter picker via 'Use Classic FilePicker' in the extras tab.

KoboldCpp v1.87.4 adds embeddings endpoint, voice cloning, Qwen2.5VL, auto tool calling, and a CLI chat mode.

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

$ koboldcpp --embeddingsmodel nomic-embed-text-v1.5.Q4_K_M.gguf

$ koboldcpp --model gemma-3-12b-it-Q4_K_M.gguf --cli

$ curl http://localhost:5001/v1/embeddings -H 'Content-Type: application/json' -d '{"input": "The quick brown fox", "model": "nomic-embed-text"}'

• ›Adds --embeddingsmodel flag to load GGUF embedding models, exposed via /v1/embeddings and /api/extra/embeddings for text encoding into vector databases.
• ›Adds --cli flag to run KoboldCpp in a fully headless terminal chat mode, with no GUI required.
• ›Adds --quantkv support without flash attention — when used without it, only quantized-K is applied (quantized-V is skipped).
• ›Adds OuteTTS voice cloning support: Speaker JSON files representing a cloned voice can now be uploaded via the TTS API.
• ›Adds automatic (auto) mode for function/tool calling, allowing the model to decide whether and which tool to invoke; the detection template is customizable via custom_tools_prompt in the chat completions adapter.

SGLang v0.4.5 adds Llama 4, FlashAttention 3, EAGLE3 speculative decoding, DeepEP MoE integration, and disaggregated prefill/decode.

$ git clone --branch v0.4.5 https://github.com/sgl-project/sglang.git
# already have the repo? check out this version:
$ git checkout v0.4.5

• ›Adds support for Llama 4 models (Llama-4-Scout-17B-16E-Instruct and Llama-4-Maverick-17B-128E-Instruct), achieving zero-shot MMLU Pro scores of 75.2 and 80.7 respectively.
• ›Adds FlashAttention 3 backend for significant acceleration on long-context inference tasks.
• ›Adds EAGLE3 speculative decoding support, delivering substantial gains in decoding throughput.
• ›Integrates DeepEP for enhanced performance in MoE (Mixture-of-Experts) inference.
• ›Introduces a prototype for disaggregated prefill and decoding.