Vectara Release Notes
Here's where we keep you up to date with all the latest features and product updates to help you get even more out of the Vectara platform. Every release is listed below, newest first.
For changes to the documentation itself — new and updated guides, context-engineering material, and API reference updates — see the Documentation Changelog.
September 2026
Point Console Documentation Links at Your Own Docs
A self-managed deployment can now point the Console's documentation links at its
own bundled docs. Set DOCS_BASE_URL for the Vectara Console and
VITE_DOCS_BASE_URL for the Admin Center; both default to
https://docs.vectara.com, and trailing slashes are stripped. The bundled docs
image now serves under /docs/ rather than the server root: a request to /
redirects to /docs/, any other root path returns 404, and the ingress must
forward /docs without rewriting it.
Why it matters: An air-gapped or on-premises deployment can keep every documentation link inside its own network.
More information:
Streamed Tool Tests with Heartbeats
Testing a tool can now stream its result. Set stream_response to true on
Test a tool or
Test a Lambda tool and the
response arrives as Server-sent Events: zero or more heartbeat events, each
carrying elapsed_ms, followed by exactly one terminal result event holding
the same object the non-streaming response returns. Heartbeats are sent every
30 seconds. A platform failure after the stream has started closes the
connection without a result, so treat a stream that ends without one as a
failed test rather than a successful one. stream_response defaults to false,
and existing non-streaming calls are unchanged.
Action required: a non-streaming test whose timeout_seconds budget exceeds
300 seconds is now rejected with 400, because no idle connection can be held
open that long. A call that used to pass a longer budget must now send
stream_response: true or lower the budget to 300 seconds or less.
Why it matters: A tool that legitimately runs for minutes can be tested without the connection being dropped by an intermediary that sees no bytes.
More information:
Longer Tool Execution Budgets
max_execution_time_seconds and a test's timeout_seconds now accept up to
21600 seconds (six hours), raised from 3600. The ceiling applies on
Create a tool, on an agent's tool-configuration
entry, and on both test endpoints.
Defaults are unchanged with one addition: when execution_configuration is
omitted entirely, a lambda that declares tool_configurations — one that calls
other tools — now resolves to 300 seconds instead of 30, because a composing
lambda waits on the tools it calls. Any other lambda still resolves to 30
seconds, and an execution_configuration supplied without the field still
declares 30. A max_execution_time_seconds on the agent's tool-configuration
entry continues to take precedence.
Remember that a non-streaming test still caps at 300 seconds; budgets above that
require stream_response: true.
Why it matters: Long-running research and batch tools no longer have to be split up to fit inside an hour, and a tool that orchestrates other tools gets a realistic default.
More information:
One Place to Declare a Connector's Type
The top-level type on
Create an agent connector is now
optional. The connector type is taken from configuration.type, and a top-level
type is treated as an optional confirmation of it: supply it and it must equal
configuration.type, or the request is rejected with 400 and
type '<x>' does not match configuration.type '<y>'. Existing requests that send
the same value in both places are unaffected.
Why it matters: A create request can no longer disagree with itself, and there is one field to get right instead of two that had to be kept in step.
Reliability Fixes for API Keys, Conversion, and Sessions
- Reading an API key no longer fails when one of its grants points at a deleted
corpus. Get an API key and
List API keys previously returned
404for the whole key; the stale grant is now omitted fromcorpus_rolesand the rest of the key is returned. - The Console lists API keys again for a user who is not an owner, admin, or
corpus admin. Those pages asked for every key in the account, which the server
refuses with
403; they now ask forapi_key_role=personaland show the user's own keys. Listing every key still requires one of those three roles. - PDF conversion no longer emits the converter's own layout scaffolding into
extracted markdown.
----- Start of picture text -----andEnd of picture textdelimiter lines, and their HTML-comment variants, are gone, and<br>tags inside picture blocks and table rows become spaces. Text found inside a picture region is still extracted; only the delimiters around it are removed. This affects the document conversion and PDF analysis agent tools, and search snippets no longer surface those markers verbatim. - Summarizing a document no longer reports an empty upstream response as a
generic
500. A successful upstream response with an empty body now returns502, and an upstream error with an empty body returns that error's own status. See Summarize a document. - A connector-driven conversation whose preferred session name is already taken now opens a session under a suffixed name rather than failing the turn, so two Slack, Google Chat, or Zoom threads can no longer collide on one name.
- Disabling a connector session now reliably stops that thread. A message arriving on a thread whose session is disabled is refused with a conflict instead of quietly starting a new session and carrying on.
August 2026
Gemini Models Accept Complex Tool Schemas
Tool schemas are now rewritten into the dialect Gemini accepts before the request
is sent, on both Vertex AI and OpenAI-compatible Gemini endpoints. oneOf
becomes anyOf, allOf is flattened, discriminator and not are dropped,
unsatisfiable required entries are stripped, unsupported format values are
removed, and definitions is normalized to $defs. Tool results are matched
back to their calls by name, and a result containing a $ref key is sent as JSON
text because Gemini reserves that key.
Why it matters: Agents whose tools use polymorphic or discriminated schemas now run on a Gemini model you bring yourself, instead of being rejected by the provider.
More information:
Wolken Tickets Pipeline Source
A new wolken_tickets pipeline source ingests incidents and service requests
from a Wolken ServiceDesk instance. Each ticket becomes one document carrying its
subject, description, and conversation notes, with classification fields such as
status, priority, category, and team as document metadata for attribute-based
filtering.
request_types selects incident, service_request, or both — unset or empty
ingests both. backfill_window is an ISO-8601 duration (days are the largest
unit) bounding how far back a first or full_refresh run reaches; unset ingests
the entire history. status_ids restricts ingestion to particular Wolken
statuses, and note_response_type_ids selects which classes of note are
included — unset includes every note, while an empty list ingests none. Both
accept at most 50 IDs, and the IDs are specific to your deployment.
ticket_url_template gives each document a portal URL through a {ticket_id}
placeholder.
Incremental syncs read only tickets updated since the previous run, and a ticket is re-ingested when notes are added. Deletions are not propagated: a ticket deleted or restricted in Wolken keeps its last indexed content. A ticket whose notes cannot be read is not ingested.
Why it matters: An agent can answer from the incident and service-request history your support team already works in, filtered to the statuses and note types you consider fit to surface.
More information:
Long Sessions Open Without Freezing the Console
Two fixes to the session view in the Vectara Console:
- Opening a long, tool-heavy session in the read-only session pane no longer hangs the browser. Pairing each tool call with its output was a scan over every message accumulated so far, so the work grew with the square of the session length; it is now a direct lookup. A tool call whose input and output land in different pages of history also renders correctly instead of being dropped.
- Agent output containing malformed or unclosed HTML no longer freezes the tab
while it renders. The markdown renderer moved from
markdown-to-jsx7 to 9.10.2, which does not degrade exponentially on that input.
Also note: the renderer's new major version escapes dangerous raw HTML tags
such as <script>, <iframe>, and <style> by default and strips dangerous
attributes from the raw HTML it does render. An agent that emits those tags in
its answer will see them displayed as text in the session view rather than
rendered — a deliberate trade for closing a cross-site scripting hole. Markdown,
and ordinary inline HTML, render as before.
Invalid Enum Query Parameters Are Rejected
A list endpoint given an unrecognized value for an enumerated query parameter now
returns 400 with the offending value named under field_errors, keyed as
query.<parameter>. Previously such a value either returned 200 with an empty
list — indistinguishable from "nothing matched" — or failed as a server error.
This applies to source_type on List pipelines,
type on List tools, tool servers, agent
connectors, and instructions, the session sort parameters, and the status,
error_type, operation, and tool_error_type filters on the agent analytics
endpoints.
Two enumerations also gained values: type on List tools now accepts vectara,
which matches the built-in Vectara tools, and source_type on List pipelines now
accepts wolken_tickets.
Action required: a caller that sends an unrecognized value and treats the empty result as "nothing matched" now receives an error instead. Correct the value, or drop the parameter to list everything.
Why it matters: A typo in a filter is now an error you can see rather than an empty page you might trust.
API Responses Are Marked Uncacheable
Every REST API response now carries Cache-Control: no-store and
CDN-Cache-Control: no-store. This covers the APIv2 endpoints, query serving, and
the v1 gateway. CDN-Cache-Control is the variant Cloudflare, Fastly, and Akamai
honor even where a configuration overrides plain Cache-Control.
Why it matters: An intermediary you place in front of the API — a CDN or a corporate proxy — cannot cache an authenticated, per-customer response and serve it to someone else.
Tool Tests Run in a Real Session
Test a tool and
Test a Lambda tool now
record the temporary session the test runs in, rather than inventing a session
key that existed only in memory. A tool that requires its session to exist —
anything that mints an artifact, directly or through a tool it calls — now
succeeds in a test instead of failing. Each test gets its own session under a
synthetic agent key; the session expires an hour after it is created, and
cleanup then removes it along with any artifacts it accumulated. Those artifacts
belong to no real agent, so treat them as test output only. If the session store is unreachable, a test now fails with
503 instead of a confusing error from inside the tool.
Why it matters: A tool you can only exercise through a full agent run is a tool you cannot debug. Tests now behave like the real thing.
Precise Status Codes for LLM Failures
Failures from a bring-your-own LLM now map to status codes that say what went
wrong. A provider timeout returns 504 with the message
The LLM request timed out. and is treated as retryable; a provider the platform
cannot reach returns 503. Both previously surfaced as 500.
Structured output truncated mid-stream now fails deterministically instead of being retried: the error names the provider-reported reason, such as reaching the output-token ceiling, and is not retried, because a retry produces the same truncation. An explicit model refusal and an empty structured-output response are reported distinctly for the same reason. The tokens the failed call consumed are still metered.
Why it matters: A timeout is now distinguishable from a defect, and a prompt or schema that cannot fit its answer in the output budget fails once with a message that names the cause instead of burning retries.
More information:
Fluid Topics Incremental Sync Reads Dataflow Reports
An incremental run of a fluidtopics source now reads the tenant's dataflow
(publishing) reports since the previous watermark and ingests only what those
reports name as changed, rather than re-enumerating the catalog and comparing
edition dates. Metadata-only changes are now detected. Deletions are still not
propagated, and a documents or topics scope with a query other than *
keeps the previous behavior.
Action required: dataflow reports require administration scope. An
incremental run whose api_key lacks it now fails with a message naming the
required scope — supply a key with administration scope in the source
configuration.
Also note: a window holding more than 1000 dataflow reports fails the run and requires a full refresh, because the reports are read serially within one activity. A source left paused for a long time against a busy tenant is the case to watch.
Why it matters: An incremental sync costs a handful of report reads instead of a full catalog walk, and a change to a topic's metadata alone is no longer missed.
More information:
Join a Slack Channel from an Agent
A new slack_join_channel tool lets an agent add its own Slack bot user to a
public channel. It takes channel_id — use slack_list_channels to find one —
and returns the channel's name, is_private, is_archived, topic,
purpose, and num_members, plus already_in_channel when the bot was already
a member, in which case the call is a no-op. A failure returns Slack's own error
code in error, such as channel_not_found, is_archived, missing_scope, or
method_not_supported_for_channel_type for a private channel, which still
requires a workspace member to invite the bot. The tool needs the channels:join
scope.
Why it matters: An agent asked to work in a channel it is not in can join it itself instead of failing until a human invites it.
More information:
Honest Storage Numbers for Aerospike 7 Clusters
The Admin Center's storage view reported 0 B of memory and storage for an
Aerospike 7.0 or newer cluster, because the statistics it read were renamed in
that release. A missing figure is no longer shown as zero: memory_used_bytes,
memory_total_bytes, storage_used_bytes, and storage_total_bytes are now
null when no node reports them, and the view shows them as unknown. A query that
succeeded but returned a partial answer — unrecognized statistic names, or nodes
that could not be reached — now carries a warning_message explaining why.
On Aerospike 7.0 and newer, note that memory_used_bytes counts index memory
only, and memory_total_bytes reports the cluster's indexes-memory-budget,
which is unset by default; where it is unset, the total is null rather than a
guess.
Why it matters: A dashboard that quietly reads zero is worse than one that says it does not know. Capacity decisions on a self-managed cluster can be made from the numbers again.
More information:
io Works on Gemini and Vertex
An agent built with io could fail every turn with a 400 when it ran on a
Gemini model through Vertex, because the schema for its read_url tool declared
an authentication choice Gemini's function declarations do not accept. The tool
now pins auth to none, which is the only mode io uses, so the schema Gemini
sees is one it can parse. Shipped in io CLI v0.2.1.
More information:
Set an LLM's Context Limit Yourself
A platform LLM registered through the Admin API or the Admin Center now accepts
an explicit capabilities.context_limit, in tokens, with a floor of 4096. The
platform used to infer the context window from the model name and provider, which
is wrong for a self-hosted or renamed model, and an inferred value silently
replaced anything you had set. A supplied limit is now preserved, returned when
you read the model, and used at request time; leave the field empty and inference
still applies. The Admin Center exposes it as Context limit on the model
form.
Why it matters: A model whose name the platform cannot recognize no longer has its context window guessed for it.
Multi-Agent Applications from the io CLI
io design now builds one web application spanning several agents: join their
keys with +, as in io design support-bot+triage-bot. The generated
application is served locally with live reload through a proxy that forwards
session, corpus, upload, and query calls, so your API key stays in the local
process and never reaches the browser page. Only the agents you named are
reachable through it, along with the corpora their tool configurations reference;
anything else is refused with a 403. Shipped in io CLI v0.2.0.
Note that io design registers a bring-your-own LLM configuration from the
Anthropic API key you supply. The registration is tenant-wide and carries a fixed
name, so it is shared rather than personal — io design logout removes it for
everyone on the tenant, and io design rotate-key replaces the credential
without removing it. Your tenant must be entitled to register a customer LLM.
Why it matters: A working front end over several agents is something you can put in front of a stakeholder the same day, without standing up a server or handing a key to a browser.
More information:
Direct Message One Person on Google Chat
A new gchat_dm_user tool sends a direct message to a single Google Chat user.
user takes either a Workspace email address, resolved through the Workspace
directory, or a Chat user resource name of the form users/USER_ID, which is
used as given. text accepts up to 32000 characters with Google Chat formatting.
The response carries ok, the space_name of the direct message space — pass it
to gchat_post_message to continue the conversation — and message_name.
reachable is false when the person has never installed the Chat app: nothing
was sent and retrying will not help. Credentials come from an attached Google
Chat connector or the gchat_service_account_key agent secret. Resolving an
email address additionally requires directory read access.
Why it matters: An agent can notify one person privately instead of posting into a shared space.
More information:
Clearer Rejection of Corrupt and Malformed Documents
A file the platform cannot parse is now rejected with 400 and the message
File could not be parsed. It may be a corrupt archive or a malformed document.
The previous behavior only recognized a corrupt archive and reported everything
else as a 500, which read as a platform failure rather than a problem with the
file. Genuine internal faults still return 500.
Extracted PDF metadata also gained the dc:title:x-default,
xmp:dc:title:x-default, and xmpMM:InstanceID fields, so documents indexed
after this change may carry metadata keys earlier ones do not.
Why it matters: A bad upload is now clearly attributable to the file, so a retry loop can stop instead of treating it as a transient error.
More information:
Docebo LMS Pipeline Source
A new docebo pipeline source ingests the course catalog of a Docebo LMS
instance through the Learn REST API. Set base_url to the instance URL — the
Learn API paths are appended for you and must not be included — and configure
auth with a credential permitted to read courses.
Each course becomes a document carrying a curriculum outline that lists the
title, type, and description of every training material in it. The materials'
own contents are not ingested. published_only defaults to true and skips any
course Docebo reports as unpublished.
Four filters narrow the catalog, all matched case-insensitively.
include_languages and exclude_languages take Docebo language codes such as
english or japanese, which matters because a catalog commonly carries the
same course once per translation. include_categories and exclude_categories
take category names; under include_categories a course with no category at all
is skipped. An exclude list wins over an include list. Every list is empty by
default, ingesting everything.
Docebo exposes no modified-since filter, so an incremental sync re-enumerates the whole catalog on each run.
Why it matters: An agent can answer training and onboarding questions from the course catalog your learners already browse.
More information:
Configured Authentication Returned on LLM Reads
Reading a configured LLM now returns the auth variant it was created with,
with every secret replaced by **** and the non-secret identifiers around it
left intact — an AWS access key id, a GCP project and region, or the header name
a key is sent in. This applies to both
Get an LLM and List LLMs.
Why it matters: Rotating a credential no longer risks silently changing the provider or auth type, because the shape you are updating is visible before you write to it.
More information:
Live Metric Charts from io
Ask io in the Vectara Console about usage, latency, token consumption, or error rates and it now answers in prose and offers a card alongside it. Clicking the card opens a metrics tab whose charts fetch live data from the metrics API themselves, so what you see is current rather than a snapshot of whatever io quoted.
A card charts between one and six metrics from the agent catalog — trace counts
and errors, input, output and cache-read tokens, average and maximum durations,
session counts, duration percentiles and distributions, and the same for tool
calls. The window is 1h, 24h, 7d, or 30d, defaulting to 24 hours, and a
card can be scoped to a single agent or left workspace-wide.
Why it matters: Operational questions end in something you can keep watching, rather than a number that is stale the moment it is printed.
More information:
Send io a File or a Screenshot
io can now look at your files. In the Console, io opens an uploaded image — png, jpeg, gif, or webp up to 2 MB — so a screenshot is something it can read rather than merely something attached to the conversation.
The io CLI v0.1.2 brings the same thing to the terminal.
/read <path> [note] uploads a local file into the session — text, PDFs, and
images — as the equivalent of the Console's file upload. /paste [note] uploads
a screenshot straight from the system clipboard, capturing it through osascript
on macOS and wl-paste or xclip on Linux. Retina screenshots routinely exceed
the 2 MB ceiling, so on macOS an oversized capture is shrunk to fit; on other
platforms /paste stops and asks you to resize the file first.
A workspace directory anchors where files land, set once through /config, the
--workspace flag, or the IO_WORKDIR environment variable. /artifacts get
downloads, /paste screenshots, and design apps under io-design/<agent-key>/
all resolve inside it. Anything placed in io-design/shared/ is visible to every
design session, so several agents' apps can draw on one set of assets.
The same release windows the CLI's model picker so the transcript stops scrolling, and coalesces store notifications during SSE bursts.
Why it matters: A screenshot of a broken dashboard is often the fastest way to ask what went wrong, and now it neither has to leave the terminal nor be described in words.
More information:
Parallel Tool Calls from Agent Code
Every callable on the sandbox tool module now also carries
tool.<name>.submit(param=value, ...). It starts the call and returns a handle
immediately instead of blocking; handle.result() waits for that one call and
re-raises tool.ToolError if it failed. Submitting several calls before
resolving any of them runs them concurrently.
The io assistant in the Vectara Console uses the same fan-out to run independent tool calls in parallel rather than one after another.
Why it matters: A lambda tool that gathers from several sources spends about as long as its slowest call instead of the sum of all of them.
More information:
Reliability Fixes
- PPTX analysis and conversion open the file as a file-backed package, so a deck with oversized embedded media no longer fails.
- Visual indexing resolves prepared image references before encoding, fixing images that could be dropped while preparing a large document.
sandbox_execkeeps its pod alive for the whole ofmax_execution_time_secondsplus a margin, so a long execution is no longer reaped mid-flight by session idle cleanup.- Persisting a simulation sample no longer clears the session's metadata.
- LLM connection checks are bounded, and cancelling an Anthropic request now reaches the provider transport instead of leaving the call running.
- Vertex AI concurrency is no longer capped by the generic per-host dispatcher limit.
- Social-login accounts resolve to the right account, and an acting-customer header now takes precedence over the JWT claim as documented.
- The io CLI
v0.1.1gates agent provisioning behind an approval in print mode and guards against a missing TTY. - The io chat column in the Console defaults to undocked.
Web Pipeline Source Fetches Pages Ahead of Processing
The web pipeline source now downloads pages before records are processed
rather than fetching each page as its record runs. At most
max_concurrent_fetches pages are fetched at once — a new parameter ranging
from 1 to 4 and defaulting to 2 — and processing a staged record does not
contact the host again. A successfully fetched page that is not available from
staging is fetched again at processing time. Failed fetches are dropped and
produce no record.
requests_per_second now accepts up to 50, raised from 20; the floor stays at
0.1. Note that the rate applies to each concurrent fetch independently, so
the worst-case rate against a host is requests_per_second multiplied by
max_concurrent_fetches.
Deprecation: max_concurrent is deprecated and no longer read. Move any
value you set to max_concurrent_fetches, whose ceiling is 4 — if you were
relying on a higher max_concurrent, your effective concurrency changes.
Why it matters: Crawls are faster and gentler on the origin, and the rate you configure now has a stated worst case rather than an implicit one.
More information:
Eleven More Google Drive Tools for Agents
Agents can now organize and collaborate in Google Drive, not only read from it.
google_drive_list_folder pages through a folder's contents and
google_drive_create_folder makes a new one. google_drive_copy_file,
google_drive_move_file, google_drive_rename_file, and
google_drive_trash_file manage files in place.
google_drive_list_permissions, google_drive_share_file, and
google_drive_unshare_file manage who has access, and
google_drive_add_comment and google_drive_list_comments work a file's
discussion.
Credentials resolve from an attached Google connector or from a service-account key held in an agent secret, as the existing Drive tools do.
Why it matters: Drive becomes a workspace an agent can act in rather than only a source it reads.
More information:
Slack Thread Fidelity and Idempotent Agent Inputs
Slack attachment_mention links — including Google Drive attachments — now
render as their display text and URL instead of unresolved markup. Messages
backfilled from a thread are delivered as real session inputs rather than
folded into context, and a streaming reply reconciles with the Slack thread it
belongs to instead of starting a new one.
Alongside this, an agent text input accepts an optional external_id of up to
255 characters. Submitting an input whose external_id the session already
holds adds nothing and returns no error, and the value is echoed back on input
events.
Why it matters: A retried delivery — a Slack redelivery or your own retry — cannot duplicate a turn, because you can key the input on an id you already own.
More information:
LLM Discovery and Model Capabilities
POST /v2/llms/discover probes an endpoint and
reports the models behind it before you configure anything. Send uri, plus an
optional type, auth, headers, and test_model_parameters. Each candidate
in the response carries type, uri, model, capabilities, verified, and
verification_error.
A request whose stated provider contradicts the endpoint, or an endpoint that
cannot be probed at all, returns 422. A model that is reachable but fails its
verification call is still returned, with 200 and verified: false alongside
the reason in verification_error.
LLMCapabilities now reports image_support, context_limit,
tool_calling, structured_outputs, and requires_role_alternation. The
platform uses each model's real context window and token density to decide when
to compact a conversation and when to offload large tool outputs, in place of a
single fixed estimate for every model.
Why it matters: You can point at a provider and see what it actually supports instead of hand-writing a configuration and finding out at runtime — and long sessions compact against the model's true window rather than a conservative guess.
More information:
Per-LLM Request Rate Limits
Configured LLMs accept a requests_per_second ceiling, from 1 to 10000, on
OpenAI-compatible, OpenAI Responses, Vertex AI, and Anthropic models. Omitting
it or sending null on create leaves the model unlimited. On update, omitting
the field keeps the current limit while sending null removes it, so you can
change other fields without disturbing the limit you set.
A call that exceeds the configured rate is rejected with 429 naming the model
and its limit. The limit is also configurable from the models form in the Admin
Console.
Why it matters: One busy agent cannot exhaust a provider quota that your other workloads depend on.
More information:
A Larger Python Environment for Lambda Tools
Lambda tools now run only in an isolated pod, and that environment is
considerably roomier. Code may import the whole Python standard library plus
numpy and pandas, where before it was limited to json, math,
datetime, collections, itertools, functools, re, time, and
typing. The temporary workspace is now writable and is discarded after each
execution, rather than being read-only. Python stays at 3.12, network access
stays disabled, custom packages are still not installable, and
max_execution_time_seconds still defaults to 30 seconds and reaches 300.
Deprecation: max_memory_mb is deprecated and ignored. Memory is fixed by
the execution environment and can no longer be set per function. Existing values
are accepted and have no effect.
Why it matters: Data-shaping code can use the tools it expects — pandas
for a table, a scratch file for an intermediate — without a workaround.
More information:
Retired HHEM Model Names Keep Working
Evaluate factual consistency
defaults to and recommends hhem_v2.3. The retired hhem_v2.2 name is still
accepted and is now served by HHEM 2.3, where it previously failed with an
opaque 404. A model name that is not recognized at all returns 400 against
body.model_parameters.model_name.
Why it matters: A client still sending the older model name keeps working
and gets scored by the current evaluator, instead of breaking on a 404 that
did not explain itself.
More information:
Session Artifacts in Lambda Code
A lambda running inside an agent session can read that session's artifacts
through the artifacts library, available without an import.
artifacts.download(artifact_id, dest_path=None) fetches an artifact and
returns its absolute local path; dest_path is relative to the sandbox scratch
directory and defaults to the artifact id. A failure — an unknown artifact id,
or a dest_path outside the scratch directory — raises ArtifactError with the
reason as its message.
Why it matters: A lambda tool can process a file another tool produced earlier in the session instead of receiving it inline.
More information:
Per-Pipeline Processing Limits
Pipeline create, update, and read models carry a processing_options object
with two settings. record_timeout_minutes, from 1 to 180, overrides the
service default of 30 minutes for a single processing attempt; a record's total
budget across all of its retry attempts is twice this value.
max_concurrent_records, from 1 to 64, caps how many of that pipeline's records
process in parallel.
On update the object is replaced wholesale rather than merged field by field, so send both fields to change one and keep the other. Send an empty object to return to the service defaults.
Why it matters: A pipeline over slow, heavy records can be given the time it needs, and a pipeline that must not saturate a fragile upstream can be told to take it slowly — without either choice affecting your other pipelines.
More information:
Richer Pipeline Run Events
Record processing events on List pipeline run events
carry more of the story. status adds a terminal dead_lettered value, emitted
once after the per-attempt failed events when a record exhausts its retries.
session_key names the agent session created to process the record, always
present on completed. attempt numbers the processing attempt that produced
the event, starting at 1, and is null on dead_lettered, which is a terminal
marker not tied to a single attempt. duration_ms reports wall-clock time on
completed and failed events when the attempt was timed. reason explains
the outcome in prose, including successful verification, where the deprecated
error field only ever carried failures; it may be null on any status when no
reason was recorded.
The error field and the boolean dead_lettered field are now deprecated in
favor of reason and the dead_lettered status.
Why it matters: You can tell a retry apart from a final give-up, jump from a record straight to the session that processed it, and see why a record succeeded rather than only why it failed.
More information:
Personal API Keys for Every User Role
Users holding any supported platform, corpus, or agent role can now create and
manage their own personal API key. Set api_key_role to personal on
Create an API key. A personal key carries the
same permissions as the user who owns it.
Users who hold none of the corpus_administrator, administrator, or owner
roles see only their own personal key: they must pass api_key_role=personal to
List API keys, and
Get an API key returns 404 for a key belonging to
someone else. Machine credentials — API keys, app clients, and service accounts —
cannot create personal keys at all.
Why it matters: A developer or agent user no longer needs an administrator to mint them a key, and the key they get is scoped to exactly what they can already do.
More information:
Caller Identity in Session Enrichment
Session enrichment tool calls can reference the platform-verified identity of
whoever created the session through session.caller.type, session.caller.id,
and session.caller.email. The type is user, api_key, or agent. A personal
API key authenticates the person it belongs to exactly as a JWT does, so it
resolves to type user rather than api_key. email may be present for those
user callers, whenever the identity record behind them carries one; it is absent
for role-based API keys and for agent service accounts, which belong to no
person. The platform derives the value from the authenticated request, so a
client cannot set it or shadow it through session metadata.
The reference resolves only during session-creation enrichment — in
session_enrichment.tool_calls and the enrichment_only tool configurations
they name. A $ref to it from a tool the agent calls mid-conversation stays
unresolved and that call fails. An absent value also fails the call closed; in an
input_transform jq expression the same absent value reads as null instead, so
guard it there.
Why it matters: An agent can scope its own work to the real caller — fetching that person's records rather than trusting a client-supplied user id.
More information:
Post to Google Chat from an Agent
Building on the Google Chat connector, agents can now send messages into a
space with the gchat_post_message tool. It requires space_name and either
text or cards. Pass thread_name to reply in an existing thread. The
response returns ok, and message_name, thread_name, and error where
applicable.
The Chat app must already be a member of the target space. Authentication
comes from an attached Google Chat connector or a service-account key stored
in the agent's gchat_service_account_key secret.
Why it matters: An agent can push results and notifications into a Google Chat space rather than only replying when it is mentioned.
More information:
Fine-Grained Confluence Cloud Page Editing
A new suite of fine-grained Confluence Cloud tools can change part of a page
without rewriting the whole page. confluence_replace_text_20260722 replaces
a specific run of visible text, confluence_replace_section_20260714 replaces
everything under a named heading,
confluence_insert_after_heading_20260714 inserts markdown directly under a
heading, confluence_append_to_page_20260714 adds content at the end or start
of a page, confluence_edit_table_20260722 adds or removes rows and columns
or sets a single cell, confluence_insert_image_20260722 places an image, and
confluence_delete_content_20260722 removes a section, block, or image while
leaving the rest of the page intact.
Three tools help an agent find its way first:
confluence_list_spaces_20260722 finds spaces by free-text name or type,
confluence_get_space_20260722 returns a space's details, and
confluence_space_page_tree_20260722 lists a space's pages as a lightweight
id, title, and parent hierarchy.
The existing full-page confluence_update_page_20260714 is unchanged and
remains available.
Why it matters: An agent can amend one part of a long page without rewriting the document and putting the rest of its content at risk.
More information:
Whole-Publication Ingestion from Fluid Topics
The Fluid Topics pipeline source accepts maps as a third content_scope,
alongside documents and topics. Under maps the source enumerates maps and
emits one record for each, rather than walking the topics inside them.
query is ignored in this scope. filters, locale, include_sources, and
exclude_sources still apply, matched against each map's own metadata — and the
reserved filter key id matches a map's identifier, so {"id": ["<map_id>"]}
restricts a run to a single publication.
Why it matters: A publication stays whole in the index instead of being split across its topics, which suits content where the surrounding document is the unit a reader cares about.
More information:
Box Agent Tool Suite
Agents can now work directly against Box through seventeen tools.
Search and read: box_search_20260723 matches free text against names,
descriptions, and file content; box_list_folder_20260723 pages through a
folder's contents; box_get_item_info_20260723 returns an item's metadata;
box_read_file_20260723 reads a document's text as markdown or plain text
without downloading it; box_get_file_20260723 downloads the raw bytes into a
session artifact; box_list_file_versions_20260723 lists a file's saved
versions.
Change content: box_upload_file_20260723, box_create_folder_20260723,
box_update_item_20260723 (rename, move, re-describe, or re-tag in one call),
box_copy_item_20260723 (a file, or a folder with its whole subtree),
box_delete_item_20260723 (moves to the Box trash), and
box_restore_item_20260723 (undoes a delete).
Collaborate: box_add_collaboration_20260723 invites a user or group with a
given role, box_shared_link_20260723 creates, inspects, or removes a shared
link, box_add_comment_20260723 and box_list_comments_20260723 work a
file's discussion, and box_create_task_20260723 opens a review or approval
task, optionally assigning it in the same call.
Why it matters: Box becomes a system an agent can act in, not only a source a pipeline reads from.
More information:
Legacy Office Formats in CoreDocument Ingestion Tools
The CoreDocument ingestion tools now accept the legacy binary Office formats alongside their modern equivalents, detecting them by content:
docx_to_core_document_20260523reads.doc. Legacy.docfiles carry no page boundaries and convert as a single page.xlsx_to_core_document_20260528reads.xls, transcoding it to.xlsxin-process so every existing option applies to both formats. Charts and embedded pictures do not survive the transcode.pptx_to_core_document_20260525reads.pptwith reduced fidelity. Slide text, titles, tables, pictures, speaker notes, and hidden-slide and master-shape handling survive; charts do not render as data tables, andextraction.notes='append'degrades to inline placement at the end of each slide.
Why it matters: Long-lived document archives ingest without a separate conversion pass, with the fidelity trade-offs stated up front.
More information:
Configurable Request Body Limit for web_get
The web_get tool accepts a max_body_bytes parameter bounding the UTF-8
byte length of the request body. It ranges from 1024 (1 KB) to 4194304
(4 MB) and defaults to 65536 (64 KB). A request whose body exceeds the limit
is rejected without being sent.
Why it matters: Agents can post payloads larger than the default to APIs that expect them, while you keep a ceiling on what any single call may send.
More information:
July 2026
SCIM 2.0 Users Pipeline Source
A new scim pipeline source ingests user records from any SCIM 2.0 service
provider through its Users endpoint. Each user becomes one document carrying
profile, group membership, and enterprise attributes as document metadata for
attribute-based filtering. Set base_url to the provider's base URL — the
Users path is appended for you — and configure auth for the provider. A
filter expression narrows which users are ingested, and attributes selects
which attributes are requested; narrowing that list narrows both what is
indexed and what is available as metadata. Choose how incremental syncs detect
changes with incremental_strategy: last_modified_filter pushes the change
window into the SCIM filter as a meta.lastModified range, and client_side
enumerates every user on each run and evaluates the window locally, for
providers that do not support filtering on meta.lastModified.
Why it matters: Agents can answer questions about people — roles, departments, reporting lines — from your directory of record.
More information:
Wolken Forms Pipeline Source
A new wolken_forms pipeline source ingests the end-user-facing service
catalog of a Wolken ServiceDesk instance, covering both incident forms and
service request forms. Each form becomes one document carrying its title,
description, and category. With include_form_details (default true), the
document also carries the form's FAQs, field definitions, field help text, and
the selectable values of its dropdown and lookup fields; those details require
credentials with read access to the form metadata, special instructions, and
lookup value endpoints. Set item_url_template with an {item_id}
placeholder to attach each form's portal URL as metadata.
Why it matters: An agent can answer "how do I request this?" from the same catalog your service desk presents, rather than from a separate copy.
More information:
Filter Wolken KB Articles by Status
The wolken_kb source accepts an article_statuses list — any of
published, retired, draft, and delete — restricting ingestion to
articles in those lifecycle states. When it is unset, articles of every status
are ingested, and an article Wolken reports no status for is always ingested.
Why it matters: You can keep drafts and retired articles out of a corpus meant to answer only from published knowledge.
More information:
Per-Tool Output Offloading Override
A tool configuration can now set tool_output_offloading to override the
agent's output-offloading behavior for that tool's outputs. Fields left unset
inherit their value from the agent's configuration, and when the object is
unset the agent's configuration applies unchanged. See
Create tool.
Why it matters: You can tune how a single tool's large outputs are offloaded without changing the agent-wide setting.
Session Scratch Pad Tool for Agents
Agents can now keep a private, session-scoped notepad with the scratch_pad
tool. It supports read, write, append, replace, and clear operations
on named pads that persist for the life of the session, so an agent can record
confirmed facts, decisions, and the next step and have them survive
summarization and long tool sequences. Each pad is stored as a session
artifact, readable with the artifact tools and reachable by sandbox code. A pad
defaults to a 1 MB limit and is configurable up to 10 MB.
Why it matters: Long-running and multi-turn agents can carry established context across turns instead of re-deriving it.
Custom Metadata on Session Artifacts
Creating a session artifact now accepts a custom metadata object of arbitrary
key/value pairs, for example original_filename or source. You can then
narrow the list-session-artifacts response with a metadata_filter expression
whose field names refer to keys on the artifact's metadata object, using a
SQL WHERE-style syntax. The filter is available on both agent sessions and
alias sessions. See List session artifacts.
Why it matters: You can tag artifacts with your own context and retrieve exactly the ones you need instead of scanning the whole session.
Per-Tool Execution Timeout
Every tool now accepts max_execution_time_seconds, the maximum wall-clock
time in seconds (1 to 3600) before a call to the tool is aborted. For
sandbox_exec it also bounds the command running inside the sandbox pod
without changing the pod's session lifetime, and for lambda tools it bounds
the function's execution, taking precedence over the tool's
execution_configuration. When unset, no timeout is applied and the tool's own
limits, if any, govern how long a call may run. See
Create tool.
Why it matters: A single slow or hung tool call no longer stalls an agent run, because you can set a hard per-tool ceiling.
End User Sessions for Agents
Agents now have a dedicated session surface for the person chatting with
them, separate from the operator session API your backend uses. Create a
session with POST /v2/agent_aliases/{alias_key}/end_user_sessions using a
credential that holds the new agent_end_user role, and the platform
enforces that the caller can only ever reach their own sessions and only
ever sees the conversation's messages, never the agent's internals.
Why it matters: You can hand the session credential directly to an untrusted client, such as a browser tab or a mobile app, without building your own proxy or writing per-session ownership checks.
More information:
Agent-to-Agent (A2A) Protocol Support
Vectara agents now implement the Agent-to-Agent (A2A) protocol over HTTP and
JSON, so external clients and other agents can discover an agent and drive it
through a standard interface. Per agent, the API exposes Agent Card discovery
(at .well-known/agent-card.json and .well-known/a2a/v1/agent-card.json),
message:send and message:stream for sending a message and streaming
response events, and task lifecycle endpoints to get a task's state and
artifacts, cancel a running task, subscribe to its updates as Server-Sent
Events, and list tasks. Both the A2A v0.3 and v1 surfaces are available. See
A2A Protocol.
Why it matters: Your agents can interoperate with A2A-compatible clients and orchestrators through a standard protocol instead of a custom integration.
Filter Agent Sessions by Metadata
The Console's agent sessions list now has a Metadata filter pane. Enter
a filter expression over session metadata, for example
author = 'John' AND year != '2026', to narrow the list to the sessions
that match.
Why it matters: You can locate specific agent sessions by their metadata instead of scanning the full list.
Choose the Entry Step for an Agent Input
An agent input event now accepts an optional entry_step field: the name
of the step the agent enters before processing that input. The value must
be a key in the agent's steps map or the agent's first_step_name. When
omitted, the session resumes at its current_step_name.
Why it matters: A caller can route a specific input to a chosen step,
for example sending a message to a triage step, rather than always
resuming where the session left off.
Live Event Updates and Side Pane in Agent Preview
The agent preview now polls for new events while a session runs, so the conversation updates as the agent works, and it presents the session in a resizable side pane.
Why it matters: You can follow an agent session as it progresses without refreshing the view.
Streamed Slack Connector Responses
The Slack connector now streams an agent's response into Slack as it is generated, updating the message incrementally instead of posting only the final reply. When streaming is not supported, the connector falls back to posting a single message.
Why it matters: Slack users see the agent's answer take shape rather than waiting for the complete response.
Google Sheets and Google Docs Tools for Agents
Agents can now read, create, and edit Google Sheets and Google Docs
through a new tool suite. Sheets tools include google_sheets_create,
google_sheets_read, google_sheets_update_cells,
google_sheets_append_rows, google_sheets_format_cells,
google_sheets_add_chart, and google_sheets_add_pivot_table. Docs tools
include google_docs_read, google_docs_edit, google_docs_insert_image,
google_docs_table, and text- and paragraph-styling tools.
Why it matters: Agents can produce and update spreadsheet and document content in Google Workspace, not only read it.
Confluence Write and Action Tools for Agents
Building on the read-only Confluence Cloud tools, agents can now act on
Confluence with confluence_create_page_20260714,
confluence_update_page_20260714, confluence_create_blog_post_20260714,
confluence_add_comment_20260714, confluence_add_label_20260714,
confluence_get_page_20260714, and confluence_search_20260714.
Why it matters: Agents can create and update Confluence content and search a space, not only fetch existing pages.
More information:
Parallel Tool Calls from Sandboxed Code
Sandboxed Python can now run independent tool calls in parallel.
tool.<name>.submit(param=value) starts a call and returns a handle
immediately, so a lambda can launch several calls and then collect their
results instead of awaiting each one in turn.
Why it matters: A lambda that makes several independent tool calls can run them concurrently, reducing the time spent waiting on sequential calls.
Template Mode Selector for Instructions and Reminders
The Console now provides a selector to set each agent instruction and each reminder to Text or Dynamic mode. Text uses the content verbatim; Dynamic interprets it as a template.
Why it matters: You can choose per instruction and per reminder whether
its content is used verbatim or interpreted as a template, without editing
the underlying template_type by hand.
Thread-History Backfill for Slack and Google Chat
When an agent is first mentioned partway through a Slack or Google Chat thread, it now backfills the thread's recent messages to build conversational context. For Google Chat, this reads the space's messages under the app's authentication and requires a Google Workspace administrator to approve domain-wide delegation.
Why it matters: An agent brought into an ongoing conversation starts with the preceding context instead of a blank history.
Tool-Call Activity and Sub-Agent Streams in Agent Preview
The agent preview now surfaces tool-call activity, grouping tool calls in the conversation, and shows sub-agent activity as waypoints.
Why it matters: You can see which tools an agent invoked and follow sub-agent activity while testing an agent.
Get Document Tool for Agents
Agents can retrieve a stored document with the new get_document tool.
The tool returns the document's text parts inline and exposes its images
and tables as artifacts that load on demand.
Why it matters: Agents can read a specific document's content directly, pulling in heavier image and table data only when a step actually needs it.
More information:
Narrow Filter Attribute Values with `fuzzy_match`
When listing the distinct values of a corpus filter attribute, you can
now pass a fuzzy_match term to narrow the results. A text value is
returned only if it contains the term, ignoring letter case and
surrounding non-alphanumeric characters — for example, 10k matches
10-K, 10K, and FY24 10-K. Numeric and boolean attribute values are
not affected.
Why it matters: It becomes practical to find matching filter values in corpora that have large attribute value sets, without scanning the full list.
Confluence Cloud Tools for Agents
Agents can now read from Confluence Cloud through two built-in tools:
confluence_fetch_20260622 retrieves page content, and
confluence_get_attachment_20260703 retrieves a page's attachments.
Why it matters: Agents can pull knowledge-base content and attached files from Confluence Cloud directly into a session.
More information:
Slack Agent Tools with Bot-Token Credentials
Slack agent tools can now authenticate with a bot token stored as the
slack_bot_token agent secret, as an alternative to attaching a Slack
connector. Store the token with
PUT /v2/agents/{agent_key}/secrets and the Slack tools use it directly.
Why it matters: Teams that already manage a Slack bot token can wire it straight into an agent's secrets without configuring a separate connector.
More information:
Set Up the Zoom Contact Center Connector in the Console
You can now create and configure a Zoom Contact Center connector directly
in the Console. Choose Zoom Contact Center when adding a connector,
then optionally set a Callback URL — provide one for asynchronous
delivery, or leave it blank for synchronous responses — and a Typing
indicator duration in seconds. After the connector is created, a
Finish setup page shows the Webhook URL to register with Zoom and
the Connector token, which is sent in the x-zoom-connector-token
header. The token is generated per connector and is preserved across
updates.
Why it matters: You can stand up a Zoom Contact Center connector and retrieve the values Zoom needs without leaving the Console.
Source Record Metadata for Pipeline Sources
Web, S3, and SharePoint pipeline sources now carry
source_record_metadata, including access-control metadata
(AclMetadata) defined in the API specification. On a partial update
(PATCH), a supplied source_record_metadata replaces the stored object
as a whole, and omitting it leaves the existing value in place.
Why it matters: Pipelines can attach and update per-source metadata — including access-control information — through the API.
Browse Agent Sessions in the Console
Selecting a session in the Console's agent sessions list now opens its full conversation in a resizable panel beside the list. The panel header includes Chat to open the session in the agent chat preview, View to open the full session view, and a control to close the panel.
Why it matters: You can review a session's conversation without navigating away from the list and losing your place.
Clearer Corpus Filter Errors in the Console
When you test an invalid metadata filter in the Console, the error now
names the problem instead of showing a generic "Filter expression has
errors" message. It suggests the closest matching key — for example,
Unknown filter key doc.catgory. Did you mean doc.category? — and flags
unquoted keys that contain spaces, dots, or dashes, showing the corrected
form (for example, doc.created at becomes doc."created at").
Why it matters: Filter mistakes are easier to spot and fix, with the Console pointing you to the likely correct key.
Google Drive and Google Docs Tools for Agents
Agents can now work with Google Drive and Google Docs through built-in tools. Drive tools search for files and get or put file content; Docs tools read a document, edit it, upload new content, and apply paragraph and text styling.
Why it matters: Agents can find, read, create, and format Google Drive and Docs content without custom integration code.
More information:
Filter Agent Aliases by Target Agent
Listing agent aliases now accepts an aliased_agent_key query parameter.
Passing an agent key returns only the aliases whose routing policy points
at that agent.
Why it matters: You can quickly discover which aliases route to a specific agent — useful when auditing routing or safely retiring an agent.
More information:
June 2026
Control Index Wait Behavior in the Document Index Tool
The document-index agent tool now takes a wait_for option.
searchable (the default) waits until the document is fully indexed and
immediately queryable — use it when a later step needs to search the
document right away. indexed returns as soon as the document is durably
stored and guaranteed to appear in future searches, which is faster and
more resilient when the indexing pipeline is busy.
Why it matters: Agents that index a document and immediately search it
can keep the default, while bulk-indexing agents can choose the faster
indexed mode.
More information:
Kubernetes Tools for Agents
Agents can now operate on Kubernetes clusters through a suite of
built-in tools: kube_get_resource, kube_list_resources,
kube_describe, kube_logs, kube_events, kube_apply,
kube_delete, kube_scale, and kube_rollout_restart. Cluster
authentication is pluggable, with providers for kubeconfig, OIDC, raw
tokens, and Amazon EKS credentials.
Why it matters: Operations and on-call agents can inspect workloads,
read logs and events, and apply controlled changes such as scaling or
restarting a rollout, without wrapping kubectl in custom tool code.
More information:
MCP File, Image, and Audio Results
Tools backed by the Model Context Protocol now surface non-text results. File bodies, images, audio, and resource links returned by an MCP server are passed through to the agent as artifacts instead of being dropped, so the agent can reason over the full result rather than text alone.
Why it matters: MCP tools that return documents, screenshots, or generated media are now fully usable from a Vectara agent, closing a gap where only the text portion of a result reached the model.
More information:
Bulk Document Metadata Update
A new endpoint applies a metadata change to many documents in a single
call: PATCH /v2/corpora/{corpus_key}/documents. Select documents
either by passing a comma-separated document_ids list (up to 10,000
per request) or by a metadata_filter expression such as
doc.status = 'archived' AND doc.year < 2020. The request body carries
the metadata object to apply and a strategy of merge (add or
overwrite only the supplied fields, the default) or replace (swap the
entire metadata object). The operation runs asynchronously by default
and returns a job_id you can track through the Jobs API, or set
async=false to wait for the updated_count, skipped_count, and
failed_count totals.
Why it matters: Re-tagging a large corpus previously meant fetching and re-writing documents one at a time. A single filtered update now reclassifies, archives, or corrects metadata across an entire corpus, which makes lifecycle and governance changes practical at scale.
More information:
GitHub Tools for Agents
Agents can now operate on GitHub repositories through a suite of 25
built-in tools covering files, commits, branches, issues, pull
requests, and search. Examples include github_get_file_contents,
github_push_files, github_create_pull_request,
github_get_pull_request_diff, github_create_issue,
github_add_issue_comment, github_search_code, and
github_update_ref. Each tool takes a github_token parameter that
you supply from an agent secret with an argument_override reference
like {"$ref": "agent.secrets.github_token"}, so the credential never
appears in the agent configuration or session history. The base URL is
configurable for GitHub Enterprise.
Why it matters: Coding and operations agents can read a repository, open and review pull requests, triage issues, and push changes without custom tool code. Paired with agent secrets, the GitHub token stays encrypted and is injected only at execution time.
More information:
More Pipeline Sources: Box, Confluence, and Wolken
Pipelines can now ingest from three additional source systems, each
selected by a type on the pipeline source configuration:
- Box (
type: box) walks a Box enterprise starting from afolder_idand inherits Box collaborations as document-level access control. It authenticates with a server-to-server Client Credentials Grant (client_id,client_secret,enterprise_id). - Confluence (
type: confluence) ingests pages from Confluence Cloud or Data Center (setdeploymentaccordingly), optionally scoped byspace_keys, and carries page read restrictions through as access control. - Wolken (
type: wolken_kb) ingests knowledge-base articles from Wolken ServiceDesk.
These join the existing s3, google_drive, sharepoint, and web
source types.
Why it matters: Each connector keeps the source system's own permissions attached to the ingested content, so a pipeline can pull from Box, Confluence, or Wolken without flattening access control or standing up an external crawler.
More information:
Glossary Tools for Agents
Two new tools let an agent manage glossary entries at runtime:
glossary_put_entries adds or updates term-to-expansion mappings, and
glossary_delete_entries removes them. Agents can now curate the same
glossaries that drive query expansion through the glossary_expansion
reminder.
Why it matters: Glossaries no longer have to be maintained out of band. An agent can capture a new acronym or product name it learns during a conversation and have it improve retrieval on the next query.
More information:
Agent Self-Scheduling with schedule_wakeup
A new per-session schedule_wakeup tool lets an agent schedule itself to
resume later. The agent supplies a delay_seconds, a prompt to deliver
back to the same session, and a reason. A later call moves the pending
wakeup earlier rather than stacking a second one, so an agent keeps at
most one scheduled resume per session.
Why it matters: Long-running and watch-style agents can wait on external state, then wake themselves to check again, without an external scheduler driving the loop.
More information:
Call Vectara Tools from Sandboxed Code
Lambda tools and sandboxed Python can now call other Vectara tools as
plain Python functions through a built-in tool module. A lambda
declares its own tool_configurations (inline or a reference to a
reusable configuration), then calls them as tool.<name>(param=value),
with tool.list() to discover what is callable and tool.ToolError
for failures. These composed tools are private to the lambda: they
never appear on the hosting agent's tool surface and produce no session
events. Any $ref to agent.secrets.* or session.metadata.* in a
composed configuration resolves against the hosting agent at execution
time.
Why it matters: A lambda can reach a credentialed REST API, search a corpus, or read an uploaded artifact while the sandbox itself stays without network access and never sees the underlying secret. To the agent, the lambda is still a single tool with one input and one output.
More information:
Plain-Text Agent Instructions
Agent instructions now accept a template_type of text in addition to
velocity. With text, the instruction is used verbatim as the system
prompt with no variable substitution, so prompts that contain literal
$ or # characters are no longer interpreted as template syntax.
Why it matters: Authors who do not need templating get predictable, literal prompts and avoid escaping. Velocity templating remains available for instructions that interpolate session or agent context.
More information:
Zoom Contact Center Connector
A Vectara agent can now serve as a Zoom Contact Center chatbot through a
new zoom connector, alongside the existing Slack and Google Chat
connectors. Zoom delivers inbound messages to the connector's webhook,
authenticated by a generated token in the x-zoom-connector-token
header. Replies are asynchronous: the webhook acknowledges with a typing
indicator and the agent's response is posted back to the Zoom-provided
callback URL when the run completes.
Why it matters: Customer-facing agents reach Zoom Contact Center without custom integration code, reusing the same agent definition, tools, and corpora that power your other channels.
More information:
Build Pipelines in the Console
Pipelines are now generally available in the Console, no longer behind a beta flag, and the no-code creation wizard covers more sources. You can configure Web, Google Drive, and S3 sources directly in the wizard, and S3 sources support include and exclude regex filters to scope exactly which objects are ingested.
Why it matters: Standing up a pipeline no longer requires the API. You can point Vectara at a website, a Google Drive, or an S3 bucket and tune what gets pulled in, all from the Console.
More information:
io: Build by Chatting in the Console
io is the AI assistant in the Vectara Console for building on the platform. Describe what you want in plain language and io scopes the work, inspects your account, proposes a configuration, and opens supported resources in the workspace. It can create and edit resources across the platform, including agents, pipelines, and API keys, and it answers questions about your account and the Vectara APIs. io never creates or updates a resource silently: for build requests it shows a confirmation card so you can review the draft, fix missing fields, and choose when to save.
Why it matters: Getting started no longer requires knowing which endpoint or Console screen to use. io turns an intent like "set up a scheduled pipeline that ingests my docs into a corpus" into a reviewable draft, while keeping you in control of what actually gets written.
More information:
Reusable Tool Configurations
A reusable tool configuration is a tool setup, such as a corpora search
bound to specific corpora or a web search with domain filters, that you
define once and attach to any number of agents by a key you choose.
Manage them with the /v2/tool_configurations endpoints, then attach
one to an agent with a reference entry in the agent's
tool_configurations map instead of restating the same configuration
inline on every agent.
Why it matters: Shared configurations remove copy-paste drift across a fleet of agents. Update the definition in one place and every agent that references it picks up the change.
More information:
Google Chat Connector
A Vectara agent can now serve as a Google Chat app through a gchat
connector, joining the existing Slack connector, and you can configure
it directly in the Console. Google Chat delivers inbound messages to the
connector's webhook and the agent replies in the same space or thread,
reusing the agent's existing instructions, tools, and corpora.
Why it matters: Teams that work in Google Chat get a Vectara agent in the tools they already use, with no custom integration code and the same agent definition that powers your other channels.
More information:
Updated Corpora Search Tool
A new dated version of the agent retrieval tool, corpora_search_20260608,
is available. It resolves corpus document tables lazily, lets image and
table results carry the matched snippet, and returns retrieved results
without an auto-generated summary. Existing corpora_search configurations
keep working unchanged; pin the dated version to opt in.
Why it matters: Dated tool versions let retrieval behavior evolve without breaking agents that depend on the current shape. The newer version is leaner for agents that do their own synthesis over results.
More information:
One Result per Document and Full-Document Context
Two query options give you more control over what retrieval returns.
Setting max_by to doc.id collapses the result set so at most one
result comes back per document, keeping the highest-scoring part of
each. Setting full_document_context to true in the context
configuration returns the entire document that contains a matching part
as context, in which case the characters_before/characters_after
and sentences_before/sentences_after windows are ignored.
Why it matters: Collapsing by document avoids burying distinct sources behind several parts of the same document, and full-document context hands the generator the whole source when a narrow window would cut off the answer.
More information:
Account Switcher
The Console can now switch between multiple accounts without logging out. Add accounts you have access to, then move between them from the account switcher, including single sign-on re-authentication where required.
Why it matters: Users who work across several accounts, such as partners and multi-tenant administrators, no longer have to log out and back in to change context.
Observability: Metrics and Traces
The Console has a new Observability view that brings agent metrics and traces together under one set of filters. A shared bar scopes both tabs by agent and time range (last hour, 24 hours, 7 days, 30 days, or a custom window). The Metrics tab charts trace volume, duration percentiles, error counts, token usage (including cache reads), active sessions, and tool-call metrics. The Traces tab lists agent runs and drills into per-span detail, filterable by status, error type, operation, tool name, and duration.
Why it matters: Operating an agent in production no longer means stitching together separate dashboards. One surface answers both "how is this agent behaving over time" and "what exactly happened in this run."
More information:
Image Embeddings for Visual Retrieval
Image-capable corpora can now embed the image parts of a document, not just its text. When a corpus uses a vLLM-shaped HTTP encoder that supports images, indexing encodes each image part inline so the corpus retrieves over visual content such as diagrams, charts, and scanned pages.
Why it matters: Documents whose meaning lives in figures and screenshots become retrievable by what they show, rather than relying on nearby text. This pairs with visual data ingestion to bring image-heavy content into search.
More information:
Document Ingestion Agent Tools
The document-ingestion tool suite for agents is now generally available, out of experimental status, with added support for spreadsheets. Agents can convert Excel workbooks to indexable documents, analyze a document's structure, and reindex content, using standardized part metadata across formats.
Why it matters: Agents that build and maintain corpora can ingest a wider range of source files, including spreadsheets, and re-process content as part of a normal tool workflow.
More information:
Agent Aliases
Agents can now sit behind an alias, a stable public name that routes each new
session to an underlying agent according to a policy you control. Callers create
sessions with POST /v2/agent_aliases/{alias_key}/sessions and the alias's
routed policy decides which agent owns the session. A policy is an ordered list
of rules, each with an optional match expression and either a single target
or a weighted split across agents. Routing resolves once at session creation
and the resolved agent_key is fixed for the life of the session.
Why it matters: Without an alias, every caller hardcodes a specific
agent_key, so changing which agent serves traffic means redeploying every
caller. An alias moves that decision to the server, enabling canary rollouts by
weight, tenant routing by session metadata, and stable handles in front of
agents whose configuration evolves, all without changing client code.
More information:
May 2026
Tool Input Transforms
Tools now support an input_transform field — a jq expression applied
to the tool's input after argument overrides are merged but before the
tool is invoked. The transform receives context including agent,
session, tools, currentDate, and the merged args, enabling
server-side input reshaping such as injecting bearer tokens from agent
secrets, pulling corpus keys from session metadata, or appending query
suffixes. Expression failures are reported to the agent as tool errors.
Why it matters: output_transform (released May 6) lets you trim
what comes back from a tool; input_transform completes the picture by
letting you reshape what goes in. Together they give full control over
the tool boundary without writing custom tool code.
More information:
Web Source for Pipelines
Pipelines can now ingest pages directly from websites using a new web
source type with three discovery modes: sitemap reads URLs from one
or more sitemaps with per-URL change detection via <lastmod> tags;
crawl performs breadth-first link-following from seed URLs; and
sitemap+crawl combines both. All modes support politeness controls
(request rate, concurrent connections, robots.txt), page count caps,
JavaScript rendering for SPAs via a headless browser service, and
authentication.
Why it matters: Before web source, getting website content into a pipeline required an external crawler writing to S3. Web source handles discovery, deduplication, and rendering natively, so you can point a pipeline at a site and let the agent decide how to process each page.
More information:
Image Analysis Tool
A new image_analysis tool enables agents to extract and analyze
visual content from image artifacts using vision-capable LLMs. The
tool supports configurable detail levels (auto, low, high) and
preprocessing options including upscaling, tiling for large images,
contrast enhancement, and sharpening — optimized for text-dense
content like diagrams, tables, and scanned documents.
Why it matters: Agents could already receive image artifacts, but had no built-in way to reason about their contents. The image analysis tool closes that gap, particularly for workflows that mix document text with charts, screenshots, or scanned pages.
Agent Secrets
Agents now have a dedicated, encrypted secrets resource at
/v2/agents/{agent_key}/secrets. Write credentials once via
PUT or PATCH, then reference them from any tool's
argument_override as {"$ref": "agent.secrets.<name>"}. The
plaintext is passed into the tool at execution time and replaced
with "****" everywhere else — on GET, on the response of
the write itself, and inside the tool_input events emitted on
the session.
Three endpoints, all gated to owner / administrator /
agent_administrator:
GET /v2/agents/{agent_key}/secrets— list secret names with masked values.PUT /v2/agents/{agent_key}/secrets— replace the full set. Names not in the request are removed.PATCH /v2/agents/{agent_key}/secrets— add or replace individual names, or remove a name by mapping it tonull.
Why it matters: Before this, the only places to put a Jira
token or Slack webhook URL were agent.metadata or a literal
value in argument_override — both of which GET /v2/agents/{agent_key}
returns in plaintext to any caller with read access on the agent.
Secrets live on a separate resource, are encrypted at rest, and
never come back as plaintext on a read. Existing agents keep
working; migrate them by writing the credential to the new
endpoint and switching the tool's argument_override to a $ref.
More information:
Throttled Reminders and Tool Output Transforms
Two upgrades for keeping long agent sessions on the rails without blowing up token cost.
Throttled reminders. Templated reminders now accept fire_every
(fire on every Nth matching event) and skip_first (skip the first N
matching events at session start). Combine them to delay a reminder
until the conversation has gone on long enough for the system prompt
to fade from the model's effective attention, then keep it firing
infrequently. Counters reset after a session compaction, so the
warmup applies again to each fresh stretch of conversation.
Tool output transforms. Every tool configuration now accepts an
optional output_transform: a jq expression applied to the tool's
JSON response before it reaches the LLM. Use it to project, filter,
or summarize verbose tool output — especially useful for search tools
that return scoring metadata, provider envelopes, and fields the
agent will never cite. Pairs naturally with web_get: trim
web_search to title/url/snippet so the agent can pick a result, and
let it fetch only the page it actually wants to read.
Why it matters: Long agentic sessions hit two predictable failure modes — instructions decaying from the system prompt as turns pile up, and tool responses crowding out useful conversation history. These features address both directly, with knobs that let you tune the trade-off per agent rather than rewriting prompts.
More information:
Pipeline Run Cancellation
Pipeline runs can now be cancelled mid-flight via
POST /v2/pipelines/{pipeline_id}/runs/{run_id}/cancel. In-progress
record processing finishes gracefully; queued records stop being
dispatched and the run transitions to a terminal cancelled state.
Why it matters: Long-running ingest jobs that turn out to be mis-targeted (wrong filter, wrong source revision, runaway agent loop) no longer have to be waited out. Cancel from the API, fix the configuration, and re-run.
More information:
LIKE Operator for Filter Expressions
Filter expressions now support SQL-style LIKE pattern matching on
text metadata columns. Patterns use standard wildcards: % matches
zero or more characters, _ matches exactly one character, and
backslash escaping (\%, \_, \\) matches literal characters.
Why it matters: Until now, metadata filters were limited to exact
match, range, and IN comparisons. LIKE adds substring and pattern
matching — useful for filtering on partial document IDs, URL prefixes,
or naming conventions without needing a separate metadata field for
each pattern.
Configurable LLM Stream Idle Timeout
CreateOpenAILLMRequest, CreateAnthropicLLMRequest, and
CreateVertexAILLMRequest now accept an optional
idle_timeout_seconds field. The platform terminates the SSE
connection if no new server-sent event arrives within this window.
When unset, the platform falls back to its default read timeout for the provider — typically 60 seconds for OpenAI and Anthropic, the SDK default for Vertex. Maximum is 3600 seconds.
Why it matters: Reasoning-heavy models, long-running tool calls, and large continuous outputs can pause for longer than the default read timeout, surfacing as a stream error in the agent loop. Raising the idle timeout gives the model room to think without the platform killing the connection underneath it.
April 2026
Tool-Output Offloading: Truncate Mode and Headroom Gate
Two upgrades to tool-output offloading make it work for every agent, not just ones with artifact tools configured.
mode: truncateshortens large tool outputs in place, keeping the head and tail and replacing the middle with a short omission notice. No artifact is created and no extra tool round-trip is needed. Mode auto-selects:artifactwhen the agent has any ofartifact_read/artifact_grep/artifact_jqconfigured,truncateotherwise.headroom_percentageis a new cumulative-context gate. When adding a tool output would push total input tokens above this fraction of the context window (default 0.70), the output is offloaded even if it would otherwise be small enough to pass through. This catches the case where many medium-sized outputs pile up over a session.
Offloading is now on by default for every agent (default
enabled: true), and the default context_percentage was raised
from 0.05 to 0.25 to better match per-output size against modern
context windows.
Why it matters: Agents without artifact tools previously had no protection against runaway tool outputs. Truncate mode gives them a zero-config safety net. The headroom gate addresses the slow-burn failure where context fills up across many tool calls without any single output being obviously too big.
More information:
SharePoint Connector
A new SharePoint connector enables ingesting files from SharePoint
document libraries via Microsoft Graph using app-only Azure AD
authentication. The connector uses Graph's /delta change-tracking
endpoint for reliable enumeration of new and modified files, supports
folder-scoped ingestion, automatic deduplication via watermarks, and
lazy-loaded custom column metadata.
Why it matters: SharePoint is where many enterprises keep their documents. The connector brings that content into Vectara pipelines and agent workflows without requiring an external ETL step or manual export.
Agent Traces
A new Agent Analytics surface for inspecting what an agent actually did. Every agent invocation now produces a trace: a tree of spans covering each LLM call, tool execution, guardrail check, step transition, compaction, and image read, with timing, token usage, status, and (optionally) the decrypted input/output content.
Four endpoints are available:
GET /v2/agent_analytics/traces— list traces with filters for agent, session, status, error type, operation, tool name, tool error type, time range, and duration thresholds.GET /v2/agent_analytics/traces/{trace_id}— fetch a trace summary.GET /v2/agent_analytics/traces/{trace_id}/spans— list spans for a trace, withinclude_content=trueto retrieve the underlying messages and tool arguments.GET /v2/agent_analytics/traces/{trace_id}/spans/{span_id}— fetch a single span.
Why it matters: Debugging agent behavior in production has been mostly guesswork. Traces give you an exact reconstruction of what the model saw, what tools it called, what they returned, and where time and tokens went — filterable down to "which traces hit a timeout in this tool" or "which sessions exceeded the context limit."
More information:
Glossaries
Agents can now expand internal acronyms, product codenames, and team
names from user messages using shared glossaries. Create a glossary of
term-to-expansion mappings once, attach it to an agent step as a
glossary_expansion reminder, and the agent receives a hint block
listing the expansions for every matching user message.
Why it matters: Enterprises have vocabulary that LLMs have no way to guess — "k8s," "PodA," "Project Atlas." Glossaries let you teach an agent that vocabulary in one place, reused across every agent and every session, without bloating the system prompt.
More information:
Pipelines
Automate bulk processing of data from external sources through agents. A pipeline pulls records from a source (S3 today, with more source types in the pipeline), spawns a fresh agent session for each record, and lets the agent decide what to do: index the record into a corpus, extract structured data, route it somewhere, or discard it. Failed records land in a dead-letter queue for retry.
Why it matters: Continuous data ingest and bulk document processing are common enterprise use cases that previously required external orchestration. Pipelines put the full flexibility of an agent behind a managed ingest loop — no cron jobs, no queue workers, no retry infrastructure to build yourself.
More information:
Agent Identity
Agents now have their own dedicated identity. Previously, an agent executed tools and accessed resources using the identity of whoever invoked it. Now each agent has its own service account with independently configurable permissions.
Why it matters: When agents ran as the calling user, every user needed permissions for everything the agent might do, and there was no way to restrict what the agent itself could access. With dedicated agent identities, you grant the agent exactly the permissions it needs — regardless of who triggers it.
March 2026
Context Compaction for Agent Sessions
Long-running agent sessions can now automatically compact their context. When a session approaches LLM token limits, compaction summarizes older events while preserving key information. You can also fork a session without compaction to branch a conversation.
Why it matters: Before compaction, long conversations would hit token limits and fail. Now agents can maintain coherent, extended conversations — useful for research sessions, ongoing customer support threads, or multi-day workflows that accumulate significant context.
More information:
Tool Versioning and Metadata
Tools now support category, lineage, version, and tool group metadata. You can mark tools as experimental and track how tools evolve across versions.
Why it matters: As your tool library grows, versioning prevents breaking changes from affecting running agents. You can deploy a new version of a tool, test it with experimental agents, and promote it when ready — without disrupting production workflows.
More information:
Tool-Output Offloading
Tools that return large payloads — multi-megabyte API responses, long
database dumps, full document text — no longer blow through your
agent's context window. When a tool's output exceeds a configurable
threshold, the platform writes it to a session artifact and hands the
agent a compact reference instead. The agent reads back what it needs
using artifact_read, artifact_grep, or artifact_jq.
Offloading turns itself on by default whenever the agent has
artifact_read configured, so most agents get the protection for
free.
Why it matters: One runaway tool response can poison an entire session, forcing the agent to spend its context budget on output it mostly doesn't need. Offloading isolates the blast radius: the agent keeps working, the prompt stays tight, and the full output is still available on demand.
More information:
February 2026
Agent Reminders
Agent steps can now carry reminders — short pieces of text that are automatically re-injected into every user input or tool output the agent sees. Reminders are how you counteract the LLM's recency bias on long sessions: a rule written once at turn 1 effectively disappears by turn 40, but a reminder keeps it near the end of the prompt where the model is still paying attention.
Why it matters: Instructions alone drift as conversations grow. Reminders let you re-assert critical constraints, dynamic per-user context, or format requirements on every turn, so the agent stays on track even across long or multi-device sessions.
More information:
- Reminders
- Glossaries — a specialized acronym-expansion reminder.
Multi-Step Agent Workflows
Agents now support multi-step workflows. Define named steps, each with its own instructions, available tools, and reminders. Steps transition based on configurable conditions.
Why it matters: Steps give you fine-grained control over an agent's behavior during a turn. Each step can have different instructions and capabilities, so you can precisely shape what the agent does at each phase of its work.
More information:
Agent Schedules
Schedule agents to execute automatically at specified intervals. Each scheduled run creates a new session, and you can view the execution history to monitor results.
Why it matters: Many agent use cases are recurring — daily report generation, periodic data quality checks, or scheduled content updates. Schedules eliminate the need for external cron jobs or orchestration tools.
More information:
Agent Skills
Organize agent capabilities into named skills that can be invoked explicitly. Skills let you direct an agent to use a specific capability rather than relying on the LLM to choose.
Why it matters: When agents have many tools, the LLM sometimes picks the wrong one. Skills give you deterministic control — invoke exactly the capability you need, especially useful for programmatic agent interactions where you know the intent upfront.
More information:
Concurrent Agent Sessions
Multiple clients can now interact with and interrupt an ongoing agent session simultaneously. This enables collaborative workflows where users and systems share a live agent session.
Why it matters: You can now steer agents mid-response — queue up follow-up messages while the agent is still working, interrupt it if it's heading in the wrong direction, or redirect its focus without waiting for it to finish. This makes agent interactions feel responsive and controllable, especially for long-running tool calls or multi-step workflows where you need to course-correct in real time.
More information:
January 2026
Structured Outputs for Agents and LLMs
Agents and LLMs can now return responses conforming to a JSON schema you define. Specify the expected output structure when creating an agent or making a chat completion request, and the response will be validated against your schema.
Why it matters: Parsing free-text LLM output is fragile and error-prone. Structured outputs guarantee the response shape, making it straightforward to feed agent responses into downstream systems, databases, or APIs without custom parsing logic.
More information:
Bulk Delete Documents
Delete multiple documents from a corpus in a single asynchronous API call. The operation runs as a background job and you can track its progress through the Jobs API.
Why it matters: Cleaning up large datasets previously required deleting documents one at a time. Bulk delete makes corpus maintenance practical for large-scale deployments where you regularly need to remove outdated or incorrect content.
More information:
Web Get Tool
Agents can now fetch arbitrary URLs using the new web_get tool.
Given any URL, the tool makes an HTTP request and returns the response
content for the agent to reason over. This works with web pages, REST
APIs, webhooks, and any HTTP-accessible endpoint.
Why it matters: web_get turns agents into general-purpose HTTP
clients. Beyond reading web pages, agents can call external REST APIs,
pull data from internal services, trigger webhooks, or fetch structured
data from any HTTP endpoint. Combined with structured outputs and
lambda tools, this makes it possible to integrate agents with virtually
any web-accessible system without writing custom tool code.
More information:
Fuzzy and Prefix Metadata Search
The metadata query API now supports fuzzy and prefix matching on field values. Find documents even with approximate or partial metadata matches.
Why it matters: Exact-match metadata filters miss documents with typos, abbreviations, or variant spellings. Fuzzy and prefix search makes metadata filtering more forgiving and practical for real-world data where values aren't perfectly normalized.
More information:
December 2025
Voice AI with Speechmatics Integration
Vectara now integrates with Speechmatics for building real-time voice agents. Combine Speechmatics' real-time speech-to-text (less than 1 second latency, and 55+ languages) and text-to-speech (TTS) with Vectara's RAG capabilities to create AI assistants that see, hear, and speak.
Why it matters: Voice interfaces are becoming essential for accessible AI experiences. This integration delivers accuracy with ultra-low latency, making it practical to build production voice agents that can answer questions from your knowledge base in real-time.
More information:
November 2025
Sub-agents: Autonomous, Specialized Agents Inside Your Agents
Vectara introduces sub-agents, a powerful new capability that lets your agents initialize dedicated, autonomous agent instances to handle additional, multi-step tasks. They accomplish all of this while keeping their context isolated from the parent agent conversation. Invoke autonomous agents for focused tasks such as code review, research, or content transformation.
Why it matters: Advanced sessions often overwhelm an agent and cause context bloat. Sub-agents solve this issue by providing a separation from the primary agent. Your parent agent stays focused while delegating work to highly specialized sub-agents that maintain an independent state, reasoning, and workflow.
More information:
Document Conversion Tool for Agents
Vectara introduces the Document Conversion Tool, a new standalone agent tool that extracts content from uploaded files and converts them into clean, structured Markdown format. These files include PDFs, Word documents, PowerPoint presentations, and images. The tool includes OCR capabilities for extracting text from images. Converted outputs persist across a session.
Why it matters: Previously, converting uploaded files into readable text required external preprocessing. This tool brings document parsing and OCR directly into agent sessions, enabling agents to interpret file types and transform them into context-ready text for reasoning, summarization, or indexing.
More information: Agent tools overview Document conversion tool
November 15, 2025
The Agents API now supports artifact storage, a persistent, session-scoped workspace for files that enables efficient multi-step document processing workflows. Artifacts provide a persistent workspace where agents and users can share files throughout a conversation without bloating the agent's context. Agents support multi-modal analysis through image artifacts (PNG, JPEG, GIF, WebP) alongside document formats. When the session expires, the artifacts are cleaned up.
Why it matters: Before artifact storage, file uploads caused context window bloat and inefficient multi-step workflows. Artifacts solve these problems by separating file storage from file references. Upload a PDF or image once, and reference it across multiple operations like conversion, visual analysis, and indexing.
What's new:
- Session-scoped storage: Files uploaded to agent sessions are stored as artifacts with unique identifiers, remaining available throughout the conversation lifecycle.
- Multi-modal support: Upload and analyze both documents and images in the same session workspace.
- Lightweight references:
ArtifactReferenceobjects contain only metadata (artifact_id, filename, mime_type, size_bytes) instead of full file contents, reducing payload sizes from potentially megabytes to ~100 bytes.
More information:
Web Search Tool Enhanced with Domain Filtering
The Web Search tool now supports domain-level filtering, enabling more precise and configurable search behavior. You can restrict results to specific domains or exclude domains entirely, including support for subdomains and wildcard patterns.
Why it matters: This enhancement gives agents more control over source quality and relevance. You can now constrain web search behavior to trusted domains or remove undesirable, or low-value sources.
More information: Agent tools overview
October 2025
Lambda Tools: Customize Python Functions in Agents
Vectara introduces the tech preview of Lambda Tools, extending agent capabilities with your own Python functions. Lambda Tools let agents execute custom business logic, calculations, or data transformations in secure, sandboxed environments.
Why it matters: Lambda Tools let you safely plug in your own logic so agents can perform domain-specific actions like scoring leads, analyzing data, or applying compliance checks, all without leaving the Vectara environment. Each function runs in an isolated Python sandbox with automatic schema discovery, resource limits, and full audit logging for transparency and governance.
New API endpoints:
- Create a Lambda Tool
- Test a Lambda Tool - This lets you test the tools you already created.
- Test Lambda Tool - This lets you test functions before creating and using them with agents.
- Update a Tool
- List Tools
More information:
September 2025
Vectara Agents Framework
We're excited to introduce the tech preview of the Vectara Agents APIs. This comprehensive framework enables building intelligent, autonomous AI agents that go beyond simple question-answering, to become configurable digital workers capable of complex reasoning, multi-step workflows, and enterprise system integration.
Why it matters: Traditional RAG applications are limited to reactive Q&A interactions. The Agents APIs enable AI agents that can autonomously reason through problems, orchestrate multiple tools, maintain conversation context, and integrate with enterprise systems through standardized protocols. This opens entirely new use cases for AI automation, from intelligent customer support to complex business process orchestration.
What's new:
- Agents APIs: Create and configure intelligent agents with customizable reasoning models, behavioral instructions, and tool access controls
- Stateful Conversations: Maintain context across multi-turn interactions with session management, enabling complex dialogues and workflow continuity
- Tool Orchestration: Agents can dynamically invoke multiple tools including:
- Corpora search for RAG capabilities
- Web search for real-time information
- Custom MCP tools for enterprise integrations
- Streaming Response Support: Real-time conversational experiences with Server-Sent Events for progressive response building
- Flexible Instructions: Combine reusable instruction templates with inline configurations using Velocity templating for dynamic agent behavior
- Chain-of-Thought Reasoning: Transparent agent thinking process with dedicated event types for reasoning visibility
- Version Management: Instructions and tool configurations support versioning for controlled rollouts and governance
New API Endpoints:
The Vectara Agent APIs introduce several new endpoints:
More information:
:::caution
- This is a tech preview release. APIs and features may evolve based on customer feedback.
- All agent and session identifiers follow the pattern
[0-9a-zA-Z_-]+without prefixes. - MCP is the only supported tool server protocol in this release. :::
August 2025
Fuzzy Metadata Search
Vectara introduces the tech preview of Fuzzy Metadata Search across document metadata fields. This capability automatically handles spelling errors and variations when searching metadata like titles, authors, categories, or custom attributes—dramatically improving document discovery rates in large repositories.
Why it matters: Traditional exact-match filtering misses relevant documents due to data entry inconsistencies or user typos. Fuzzy Metadata Search solves this by applying intelligent matching algorithms that find "Employment Agreement" even when users search for "Employement Agrrement", making document discovery more forgiving and effective.
Key capabilities:
- Multi-field weighted search with customizable importance scores
- Two-stage processing: exact pre-filtering followed by fuzzy matching
- Automatic handling of typos, transpositions, and spelling variations
- Support for both document-level and part-level metadata
New API endpoint:
More information:
Vectara Postman Collection: Faster API Exploration and Testing
Vectara published the official Postman Collection, giving developers an easy, code-free way to explore and test the Vectara REST APIs. The collection includes pre-configured requests for common operations, such as creating corpora, indexing documents, and running semantic searches—organized into folders for quick navigation. It supports both API key and OAuth 2.0 authentication, making it flexible for rapid prototyping or secure production workflows.
Why it matters: Getting started with a new API can involve a lot of trial and error. The Vectara Postman Collection provides ready-to-use requests and example payloads, so you can focus on experimenting with Retrieval-Augmented Generation (RAG) workflows and integrating them into your applications faster. Whether you’re building a proof-of-concept or refining a production integration, Postman makes it easy to interact with Vectara’s endpoints, inspect responses, and iterate on your requests in real time.
What’s new:
- Official Vectara Postman Collection published on the Postman API Network.
- Pre-configured requests for creating corpora, indexing documents, querying
data, and managing resources. - Authentication support for API key and OAuth 2.0 (Client Credentials)
flows. - Organized folders for Corpora Management, Indexing, Querying, and
Administration. - Sample payloads and parameters included for faster learning and testing.
More information:
July 2025
Vectara Admin Center: Centralized Control for On-Premise and VPC Deployments
Vectara introduces the Admin Center, a unified interface designed to streamline the management of on-premise and VPC deployments. The Admin Center empowers DevOps and IT Admin teams with comprehensive visibility and control, helping prevent RAG sprawl and reducing operational overhead.
Why it matters: Managing AI infrastructure on your own servers demands clarity, efficiency, and tight access control. The Vectara Admin Center centralizes administrative operations, enabling teams to monitor system health, manage tenants and users, register LLMs, and track resource usage from a single dashboard. This reduces manual effort, improves security, and gives organizations the flexibility to scale and optimize their Vectara environment with confidence.
What’s new:
- System Health Monitoring: Instantly view the overall status of your Vectara deployment, including tenants, queries, and indexing activity.
- Tenant & User Management: Easily manage tenant accounts, user permissions, and quotas through a streamlined interface.
- Model Registration: Centrally register and manage custom Large Language Models (LLMs) for consistent usage across all teams.
- Corpus Oversight: Quickly audit corpora within any tenant, with options to rebuild or resolve issues for optimal performance.
- Bug Reporting: Collect relevant logs and generate detailed bug reports to accelerate troubleshooting and support.
More information:
Vectara Python SDK Documentation
Vectara now offers comprehensive documentation for the new Vectara Python SDK, making it easier than ever to integrate Vectara’s platform with Python-based applications. The SDK streamlines common tasks such as authentication, query management, and response handling, all while using familiar Python patterns.
Why it matters: Python is the go-to language for many AI and data engineering teams. With this SDK and the new documentation, developers can get started faster, implement best practices with less effort, and focus on building solutions instead of boilerplate code.
What you’ll learn:
- How to install and configure the Vectara Python SDK
- Key methods for querying, indexing, and retrieving data
- Authentication and security best practices
- Tips for handling responses, errors, and pagination
- Example workflows for RAG and generative AI applications
More information:
Vectara Python SDK Documentation Vectara Python SDK on GitHub
Open RAG Eval: Consistency-Adjusted Index for RAG System Evaluation
The Open RAG Evaluation tool now offers the consistency-adjusted index to evaluate both the quality and consistency of responses generated by RAG systems. This metric assesses the strength of the answers, and also how reliably the system produces those high-quality results when faced with repeated queries.
Why it matters: In production and enterprise scenarios, consistency is as important as accuracy. The consistency-adjusted index combines both quality and stability into a single, actionable score. This metric enables you to quickly identify when your RAG system is delivering trustworthy results, and when variability or lower quality requires further attention. A higher index means your system reliably produces high-quality responses, while a lower index indicates the need for deeper investigation and improvement.
More information:
June 2025
VHC Enhanced for Query-Aware Hallucination Detection and Correction
Vectara has enhanced the Hallucination Corrector (VHC) API with support for query-aware hallucination detection and correction. This upgrade introduces the ability to include the original user query in VHC requests, enabling more accurate analysis of model-generated text.
Why it matters: In RAG workflows, generated responses often reflect both the retrieved context and the phrasing or intent of the user query. Adding the optional query field to VHC requests enables the model to interpret response formatting better. This helps resolve ambiguities, and attribute facts that are inferred from the query rather than only the source. This results in improved correction accuracy, particularly for instructions like “Answer True or False,” “List the top 3,” or “Summarize concisely.”
What’s new:
- The
modelparameter has been renamed tomodel_name, - Added an optional
queryfield for VHC requests to activate a query-aware prompt. - Improved correction precision in prompt-sensitive use cases
More information:
HHEM 2.3 - Additional Language Support and Enhanced Architecture
Vectara’s Hughes Hallucination Evaluation Model (HHEM) now supports three additional languages: Russian, Japanese, and Hindi. This update increases the total supported languages from 8 to 11, further enhancing accessibility and global usability.
Languages now supported: English, German, French, Spanish, Portuguese, Arabic, Chinese (Simplified), Korean, Japanese, Hindi, and Russian.
This release also introduces a significant update to HHEM’s architecture, resulting in reduced operational costs and improved performance and accuracy.
Why it matters: By expanding multilingual support, Vectara further reduces reliance on manual translations, enabling global teams to directly evaluate AI accuracy in their native languages. The enhanced architecture delivers cost-effective performance improvements, promoting broader, confident adoption of trustworthy AI solutions.
More information:
May 2025
Vectara Hallucination Corrector (VHC) API
Vectara introduces the tech preview release of the Vectara Hallucination Corrector
(VHC) API, a new capability designed to evaluate and revise AI-generated
summaries for factual accuracy. The VHC endpoint compares a generated summary
to one or more source documents and returns a corrected version, applying only
the minimal changes needed to align the summary with the source material.
Why it matters: In Retrieval Augmented Generation (RAG) workflows, LLMs commonly introduce inaccuracies or hallucinations. The Vectara Hallucination Corrector offers a targeted solution by enabling automatic, explainable corrections to text based on reliable context—preserving the original phrasing wherever possible. This improves trust, precision, and usability of AI-generated outputs across enterprise applications.
New API endpoints:
More information:
April 2025
Chat Completions API
Vectara now offers an OpenAI-compatible Chat Completions API, enabling seamless integration of Vectara’s language models into applications already built for OpenAI’s chat endpoint. This API supports both synchronous and streaming response formats and adheres to the familiar message-based interface used for conversational AI.
Why it matters: Developers can now integrate Vectara’s models into chat interfaces, agents, and customer-facing applications without needing to rearchitect prompt flows or backend systems. The compatibility layer makes it easy to switch between providers or test performance across models, all while tracking usage and applying fine-grained generation controls.
New API endpoint:
Evaluate Factual Consistency API
Vectara introduces the tech preview of the Evaluate Factual Consistency API, a new endpoint that assesses how well a generated summary or response aligns with its supporting source documents. This API provides a confidence score indicating whether a given text is grounded in the referenced material—helping developers detect and respond to hallucinated content in LLM outputs.
Why it matters: As enterprises rely more heavily on generative AI for summarization, Q&A, and knowledge tasks, the ability to detect factual inconsistencies becomes critical. This API enables automated quality control by scoring alignment between generated text and source documents, improving the reliability and auditability of AI-generated content.
New API endpoint:
Mockingbird 2: Vectara's Advanced LLM for RAG
Vectara releases Mockingbird v2, an advanced Large Language Model (LLM) optimized for Retrieval Augmented Generation (RAG) with cross-lingual capabilities. Mockingbird v2 introduces support for queries, documents, and summaries in different languages, enhanced generation quality, and robust hallucination mitigation, making it ideal for global enterprise applications.
Why it matters: Mockingbird v2 enables organizations to process multilingual datasets seamlessly, delivering precise summaries across English, Spanish, French, Arabic, Chinese, Japanese, and Korean. With a 0.9% hallucination rate in its Mockingbird-2-Echo configuration, it ensures trustworthy outputs for research, knowledge bases, and question-answering systems.
More information:
Custom Table Summarization with Prompt Templates
Vectara now supports custom prompt templates for table summarization during
document upload. This enhancement enables users to define exactly how extracted
table data should be summarized using an OpenAI-compatible LLM. The
prompt_template is configured with the table_extraction_config parameter
in the File Upload API and supports Apache Velocity syntax for referencing
table structure and content.
Why it matters: If you work in a domain with structured tabular data, summarizing tables with LLMs can surface key insights automatically. This capability allows you to tailor how summaries are generated by injecting domain-specific language, tone, and formatting preferences—resulting in more relevant, actionable outputs.
Updated API Endpoint:
More information:
March 2025
Expanded Encoder Management
Vectara introduces the Create Encoder API, allowing users to register and configure custom text embedding encoders for seamless integration within the Vectara platform. This API supports OpenAI-compatible encoders, enabling users to define authentication details, model parameters, and API endpoints for enhanced embedding workflows.
Why it matters: Organizations using AI-powered search and retrieval applications can now manage multiple encoder configurations tailored to their specific needs. This capability provides greater flexibility in defining custom embedding models, optimizing similarity search, document retrieval, and other AI-driven use cases.
New API Endpoint:
Vectara Kafka Connect Plugin Integration
Vectara introduces the Vectara Kafka Connect Plugin, enabling seamless real-time integration between Confluent Cloud and Vectara. This plugin enhances data streaming capabilities by providing scalable, schema-aware processing for efficient vector search workflows.
Why it matters: This integration allows organizations to leverage real-time data ingestion for AI-powered search, recommendation engines, and advanced analytics, optimizing knowledge retrieval from streaming data.
More information:
February 2025
Integrate External Large Language Models (LLMs)
Vectara introduces the tech preview of the Create LLM API, enabling users to integrate and configure external Large Language Models (LLMs) for use with query and chat endpoints. This API enables connectivity with models compatible with OpenAI API specification, including Anthropic Claude, Azure OpenAI, and custom-hosted LLMs.
compatible with OpenAI API specification
Why it matters: "Organizations need control over the LLMs they use in AI application development, including configuration, authentication, and deployment. This capability provides that flexibility by allowing users to connect external LLM providers, define authentication methods, and specify model parameters and API endpoints—all within a single API.
New API endpoint:
Document Summarization API
Vectara introduces the tech preview release of the Document Summarization, enabling users to generate concise summaries from lengthy documents such as technical reports, vendor quotes, and financial statements. This API helps streamline information retrieval by allowing users to extract key insights without manually reviewing entire documents.
Why it matters: The Document Summarization API addresses a critical need for organizations dealing with large volumes of unstructured content. By leveraging Retrieval Augmented Generation (RAG), users can generate summaries that capture the most relevant information, significantly reducing time spent on document analysis.
New API endpoint
Intelligent Query Rewriting
Vectara introduces the tech preview release of Intelligent Query Rewriting, a capability that enhances search accuracy by automatically generating metadata filter expressions from natural language queries. This innovation enables users to search naturally while ensuring more precise results by applying context-aware filters in the background.
Why it matters: Intelligent Query Rewriting bridges the gap between natural language queries and structured data, improving search precision without requiring user intervention. It reduces query refinement time, streamlines workflows, and provides full transparency by including generated filters and rephrased queries in the API response and query history.
More information:
January 2025
Knee Reranking
Vectara now offers Knee Reranking, an advanced dynamic filtering tool designed to improve the precision of query results by automatically identifying natural cutoff points between relevant and irrelevant results. This feature integrates seamlessly into Vectara's reranking chain, following the Slingshot reranker (Vectara Multilingual Reranker V1), to refine search outputs with advanced score pattern analysis.
Why it matters: Knee Reranking elevates the quality of retrieval in Retrieval Augmented Generation (RAG) systems by adapting to the unique score distribution of each query dynamically. By automatically filtering out less relevant results, users receive more focused and actionable results, and experience reduced latency and improved accuracy from limiting irrelevant data sent to downstream systems.
More information:
HHEM 2.2 - Expanded Language Support
Vectara’s Hughes Hallucination Evaluation Model (HHEM) now supports five additional languages: Portuguese, Spanish, Arabic, Chinese, and Korean. This update increases the total supported languages from 3 to 8, expanding accessibility and usability for global teams. Additionally, the context window has been expanded from 8k to 16k tokens and latency has been reduced.
Why it matters: This enhancement reduces the need for manual translations, enabling customers to evaluate AI accuracy directly in their preferred languages. By simplifying workflows and enhancing multilingual support, it builds trust in AI systems and Vectara’s platform while empowering teams to address diverse linguistic challenges more effectively.
More information:
December 2024
API v1 Deprecated
Vectara announces the official deprecation of API v1, which will be retired on August 16, 2025. This milestone marks a shift towards leveraging the full capabilities of API v2, offering enhanced functionality, improved developer experience, and streamlined authentication mechanisms. Users are encouraged to migrate their applications to API v2 as soon as possible to ensure uninterrupted service.
Why it matters: REST API v2 improves upon the previous release with standard HTTP response codes, a more intuitive REST URL structure, and new functionality, such as client-side timeouts. Migrating to API v2 allows users to benefit from these improvements while ensuring long-term platform compatibility.
More information:
Update or Replace Document Metadata
Vectara now enables users to update document metadata without reindexing. This capability supports two distinct operations: merging new metadata into existing metadata or replacing the metadata entirely. Both operations are now available through dedicated API endpoints.
Why it matters: Managing metadata is a critical part of ensuring that search and retrieval systems reflect the most up-to-date information. The ability to merge new metadata incrementally enables users to add or adjust specific fields without affecting existing data, while the full replacement operation is ideal for scenarios requiring a clean update. By streamlining metadata updates without reindexing document content, this feature enhances efficiency and ensures smooth document lifecycle management.
New endpoints:
More information:
Querying Table Data
Vectara introduces table querying, a powerful feature designed to help users extract and interact with structured tabular data embedded within documents. By enabling table data extraction during document ingestion, users can leverage Vectara’s advanced APIs to retrieve specific cells, compare semantic values, and gain actionable insights from tables in reports, filings, and other structured documents.
Why it matters: This powerful capability addresses the challenge of retrieving precise information from tables that are often large and complex. With table querying, analysts, researchers, and business users can focus on meaningful insights, reducing the time spent parsing tables manually. Key benefits include quick access to specific data points and streamlined analysis of financial, market, and operational data.
Updated API endpoints:
More information:
Query Observability
Vectara introduces query observability, which enables users to gain deeper insights into query performance and outcomes. Our query observability tool allows developers, business users, and machine learning teams to analyze individual queries by tracking key metrics, inspecting query configurations, and reviewing the execution process. With a detailed breakdown of each query's call stack, users can debug, optimize, and fine-tune their queries for improved relevance and performance.
Why it matters: This feature solves the problem of limited observability into query execution. By surfacing data like query latency, search results, reranking, and generative response times, users can better understand how Vectara’s system performs relative to their business goals.
Updated API endpoints:
More information:
October 2024
New Integrations Section
Vectara introduces a new documentation section highlighting our integrations with various systems in the larger generative AI community, including Airbyte, DataVolo, Flowise, LangChain, LangFlow, LlamaIndex, and Unstructured.io. This section showcases how Vectara's advanced capabilities in document indexing and neural retrieval can enhance AI applications through strategic partnerships.
Why it matters: This update provides developers with an overview of Vectara's community and partner integrations, enabling them to leverage powerful tools and frameworks in conjunction with Vectara's capabilities. These integrations can enable developers to more easily enhance their AI applications, improve search accuracy, and streamline their development process.
More information:
Search Cutoffs and Limits
This feature introduces cutoffs and limits for search results. Cutoffs set a minimum relevance threshold, while limits control the maximum number of returned results after reranking. These can be applied individually or combined across various reranker types.
Why it matters: These controls allow developers to customize reranker inputs, ensuring highly relevant results and optimizing resource usage. By enabling more precise result filtering, application builders have more flexibility for specific use cases, from content categorization to focused data retrieval.
Updated API endpoints:
More information:
Chain Reranker
The Vectara chain reranker lets you apply multiple reranking strategies sequentially, allowing users to combine different reranking strategies and giving you absolute control. This feature enables the application of diverse ranking criteria at each stage of the ranking process, from neural reranking and maximal marginal relevance to custom business logic, all in a customizable sequence.
Why it matters: This unique innovation addresses complex search scenarios that require complex relevance and business rules and enables enterprises to fully customize Vectara's behavior. By allowing the combination of various reranking strategies, it significantly enhances the quality of Retrieval Augmented Generation (RAG) outcomes.
Updated API endpoints:
More information:
Document and Document Part/Vector Count API
You can now retrieve more comprehensive metrics about a corpus, including the number of documents or document parts.
Why it matters: Administrators can now efficiently manage resource allocation and monitor data usage trends. This feature helps ensure that corpus growth stays within allocated quotas and provides insights into document segmentation patterns.
Updated API endpoint:
Retrieve metadata about a corpus
August 2024
UI Enhancement: Custom Prompts in Console
The Vectara Prompt Engine allows users to create customized prompt templates that can reference relevant text and metadata for Retrieval Augmented Generation (RAG) applications.
Why it matters: This feature enables more advanced workflows and customizations for creating context-aware responses, such as answering questions based on previous answers in RFIs or RFPs, drafting support tickets from user feedback, and customizing result formatting. The ability to define roles and provide detailed context in prompts helps guide LLMs to generate more accurate and relevant responses.
More information:
User Defined Function Reranking
Vectara introduces the User Defined Function Reranker, giving enterprises more granular control over search result ordering by defining custom reranking functions using document-level metadata, part-level metadata, or scores generated from the request-level metadata. This flexibility is particularly useful for a wide range of use cases.
Why it matters: This feature allows enterprises to modify scores based on metadata, conditions, and custom logic, in order to craft highly tailored search experiences. This advanced functionality can guide LLMs to prioritize certain information, especially when used with the chain reranker. Use cases can include recency bias for news searches, location bias for local business queries, and e-commerce bias for promotional content.
More information:
July 2024
Mockingbird LLM
Vectara releases Mockingbird, our Large Language Model optimized (LLM) designed for Retrieval Augmented Generation (RAG) scenarios. It offers enhanced accuracy and improved performance in summarizing large datasets, generating structured data, and providing multilingual support.
Why it matters: Mockingbird outperforms leading models in RAG quality, citation accuracy, and structured output precision. It's particularly valuable for enterprises requiring accurate summaries of large data volumes, structured data extraction, and multilingual capabilities. Mockingbird supports critical languages including Arabic, French, Spanish, Portuguese, Italian, German, Chinese, Dutch, Korean, Japanese, and Russian, making it ideal for global applications.
More information:
June 2024
Vectara REST API v2
The Vectara API v2 provides a more RESTful, intuitive structure with simpler authentication, new top-level objects, and better defaults for hybrid search and reranking, making it easier to develop applications with Vectara’s GenAI platform.
Why it matters: This update significantly improves the developer experience, making it easier to integrate Vectara into applications. The standardized error codes and improved defaults reduce development overhead and potential silent errors.
New API endpoint(s):
May 2024
Vectara Multilingual Reranker v1 (Slingshot)
The state-of-the-art Vectara Multilingual Reranker, also known as Slingshot, provides more accurate neural ranking than the initial Boomerang retrieval. By significantly improving the precision of retrieved search results, Slingshot enhances the performance of Retrieval Augmented Generation (RAG) pipelines. It excels in globally distributed, multilingual environments, reducing irrelevant responses and minimizing hallucinations in generative AI applications.
Why it matters: Slingshot significantly enhances the precision of retrieved results, crucial for reducing hallucinations and irrelevant responses in generative AI applications. While computationally more expensive, it offers improved text scoring across a wide range of languages (100+), making it suitable for diverse content as a powerful tool for enterprises.
Deprecated: The reranker_id and rnk_272725719 have been deprecated.
Use reranker_name and Rerank_Multilingual_v1 instead.
More information:
- Vectara Multilingual Reranker
- Unlocking the State-of-the-Art Reranker: Introducing the Vectara Multilingual Reranker_v1
Semantic Conversation History Search
Vectara now allows administrators to search across conversation logs for specific patterns or unresolved queries. This leverages semantic search capabilities to identify gaps in knowledge bases and pinpoint "unknown unknowns" in conversations where users may have asked unexpected or unresolved questions.
Why it matters: With this capability, enterprises can enhance their customer support by analyzing user interactions and improving response accuracy. They can identify unresolved or ambiguous user questions, even if the language is informal or the question does not fit specific patterns.
More information:
Semantic Conversation History Search
Generative Response Styling
Vectara now allows users to format citations in summaries using Markdown or HTML and including document and part level metadata directly in citation links. This feature is useful for enterprises that require formatted, context-rich summaries for integrating generative responses into web-based applications and ensuring citations are clear and appropriately formatted.
Why it matters: By allowing structured citations, Vectara simplifies the integration process for developers who need to embed references directly into user-facing applications without additional parsing logic. This improvement enhances usability for various platforms, including web-based content and internal systems that support HTML or Markdown.
More information: