> ## Documentation Index
> Fetch the complete documentation index at: https://docs.seekr.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Release notes 2026

export const ReleaseTags = ({type, deployment}) => {
  const base = {
    display: "inline-block",
    padding: "2px 8px",
    borderRadius: "3px",
    fontSize: "11px",
    fontWeight: "600",
    marginRight: "4px"
  };
  const typeStyle = {
    feature: {
      backgroundColor: "#d0f4de",
      color: "#1b4332",
      border: "1px solid #52b788"
    },
    improvement: {
      backgroundColor: "#fef3c7",
      color: "#92400e",
      border: "1px solid #fcd34d"
    },
    "bug-fix": {
      backgroundColor: "#ffe5d9",
      color: "#6d0011",
      border: "1px solid #ff6b6b"
    }
  };
  const typeLabel = {
    feature: "Feature",
    improvement: "Improvement",
    "bug-fix": "Bug Fix"
  };
  const deployStyle = {
    "seekr-managed": {
      backgroundColor: "#c7f9cc",
      color: "#004b23",
      border: "1px solid #00cc88"
    },
    "self-hosted": {
      backgroundColor: "#d3e4fd",
      color: "#023e8a",
      border: "1px solid #4361ee"
    }
  };
  const deployLabel = {
    "seekr-managed": "Seekr-managed instance",
    "self-hosted": "Self-hosted instance"
  };
  const deployments = Array.isArray(deployment) ? deployment : deployment ? [deployment] : [];
  return <div style={{
    marginBottom: "8px"
  }} className="not-prose">
      {type && <span style={{
    ...base,
    ...typeStyle[type]
  }}>{typeLabel[type]}</span>}
      {deployments.map(d => <span key={d} style={{
    ...base,
    ...deployStyle[d]
  }}>
          {deployLabel[d]}
        </span>)}
    </div>;
};

export const SupportedOn = ({ui = false, api = true, sdk = true}) => <div className="inline-flex flex-wrap items-center gap-x-5 gap-y-2 px-4 py-2.5 rounded-lg border border-[#00dad3] bg-[#00dad3]/10 text-sm not-prose">
    <span className="font-bold text-black dark:text-white whitespace-nowrap">
      Supported on
    </span>
    <div className="flex items-center gap-5">
      <span className="inline-flex items-center gap-1.5 font-semibold text-black dark:text-white">
        <Icon icon={ui ? "circle-check" : "circle-xmark"} color={ui ? "#00dad3" : "#9ca3af"} size={16} />
        UI
      </span>
      <span className="inline-flex items-center gap-1.5 font-semibold text-black dark:text-white">
        <Icon icon={api ? "circle-check" : "circle-xmark"} color={api ? "#00dad3" : "#9ca3af"} size={16} />
        API
      </span>
      <span className="inline-flex items-center gap-1.5 font-semibold text-black dark:text-white">
        <Icon icon={sdk ? "circle-check" : "circle-xmark"} color={sdk ? "#00dad3" : "#9ca3af"} size={16} />
        SDK
      </span>
    </div>
  </div>;

<Update label="June 19, 2026" tags={["Feature"]}>
  ## Add, filter, and edit custom chunk metadata

  <ReleaseTags type="feature" />

  <SupportedOn ui={false} api={true} sdk={true} />

  You can attach user-defined metadata to the chunks in a vector database and use it to refine retrieval. Add a flat set of fields, such as year, document type, or confidentiality level, when you ingest files, then list or filter chunks by those fields using exact matches or range operators. Metadata on existing chunks can also be edited, targeted by chunk or by file. Filtering by metadata improves retrieval precision on large, mixed collections where time period, document type, or business unit matters.

  For details, see [Manage chunk metadata](/flow/sdk/data-engine/manage-chunk-metadata) and [Create and populate a vector database](/flow/sdk/data-engine/create-and-populate-a-vector-database).
</Update>

<Update label="June 12, 2026" tags={["Feature"]}>
  ## Trace agent responses back to their source documents

  <ReleaseTags type="feature" />

  <SupportedOn ui={false} api={true} sdk={true} />

  Source tracing connects an agent response to the exact location in the document it came from. When a file is ingested into a vector database, provenance metadata is captured for every chunk, including its line range, character offsets, heading hierarchy, and source page. File search results carry this metadata, and a chunk endpoint returns the full provenance record, including the original file ID, so you can follow a response from model output back to the source document. This supports auditability, compliance, and chain-of-custody workflows.

  For details, see the [source tracing overview](/flow/components/explainability/source-tracing) and the [source tracing developer guide](/flow/sdk/explainability/source-tracing).
</Update>

<Update label="June 9, 2026" tags={["Feature"]}>
  ## Partially update agents and tools

  <ReleaseTags type="feature" />

  <SupportedOn ui={false} api={true} sdk={true} />

  New PATCH endpoints for agents and tools update individual fields without requiring the full configuration. Only the fields included in the request are changed; omitted fields remain unchanged. Use the corresponding diff endpoints to preview changes before applying them.

  * Update an agent: [SDK](/flow/sdk/agents/create-agents#update-an-agent) | [API](/flow/reference/patch_v1_flow_agents__agent_id__patch)
  * Preview an agent update: [SDK](/flow/sdk/agents/create-agents#preview-an-agent-update) | [API](/flow/reference/diff_v1_flow_agents__agent_id__diff_patch)
  * Update a tool: [SDK](/flow/sdk/agents/tools#update-a-tool) | [API](/flow/reference/patch_tool_v1_flow_tools__tool_id__patch)
  * Preview a tool update: [SDK](/flow/sdk/agents/tools#preview-a-tool-update) | [API](/flow/reference/diff_tool_changes_v1_flow_tools__tool_id__diff_patch)
</Update>

<Update label="May 21, 2026" tags={["Feature"]}>
  ## Edit agents directly in the UI

  <ReleaseTags type="feature" />

  <SupportedOn ui={true} api={true} sdk={true} />

  You can now edit an agent's configuration directly from the UI. Select an agent from the agents list and click **Edit** to update its name, instructions, model, or tools.

  For details, see [Manage agents](/flow/app/manage-agents).
</Update>

<Update label="May 7, 2026" tags={["Feature"]}>
  ## MCP connector support for agents

  <ReleaseTags type="feature" />

  <SupportedOn ui={false} api={true} sdk={true} />

  Agents can now connect to external Model Context Protocol (MCP) servers using the MCP connector tool. SeekrFlow routes outbound requests through a secure internal gateway and handles authentication and token refresh automatically.

  To set up an MCP connector tool, create it via the API or SDK with your MCP server URL. Three authentication modes are supported:

  * Servers with dynamic client registration (DCR)
  * OAuth servers without DCR (bring your own `client_id` and `client_secret`)
  * Unauthenticated servers

  OAuth-based modes require a one-time authorization step before the tool becomes active. Once active, the tool can be linked to any agent.

  For more information, see [MCP connector](/flow/sdk/agents/mcp-connector).
</Update>

<Update label="April 29, 2026" tags={["Feature"]}>
  ## Role-based access control for team collaboration

  <ReleaseTags type="feature" />

  <SupportedOn ui={true} api={false} sdk={false} />

  SeekrFlow now supports role-based access control (RBAC), opening up team-based development across the platform. Resources — including agents, fine-tuning jobs, deployments, files, and vector databases — are owned by teams and accessible to all members of that team based on their assigned role.

  Key concepts:

  * **Organization** – The top-level container. All users belong to one organization.
  * **Teams** – Where work happens. Resources are scoped to a team.
  * **Roles** – Organizations have Owner and Member roles; Teams have Admin and Creator roles.

  Users can belong to multiple teams and switch between them using the team switcher in the UI.

  <Info>
    Agent conversation history (threads) remains user-owned and is not shared with team members.
  </Info>

  **Existing users:** All users have been migrated into an organization, and existing resources now live in a private team scoped to you. Select users have been assigned the Owner role.

  To get started, create a Team for a shared workstream, add members, assign roles, and use the team switcher to move between contexts. See [Role-based access control](/flow/role-based-access-control) and [Managing permissions](/flow/app/manage-permissions) for details.
</Update>

<Update label="April 8, 2026" tags={["Feature"]}>
  ## Track file and vector database dependencies across your environment

  <ReleaseTags type="feature" />

  <SupportedOn ui={false} api={true} sdk={true} />

  New usage endpoints surface file and vector database dependencies across tools, agents, and data jobs in your SeekrFlow environment.

  **File usage endpoints** return the downstream dependencies of a given file:

  * `GET /files/{file_id}/vector-dbs` – Vector databases that ingested this file.
  * `GET /files/{file_id}/data-jobs` – Data jobs that reference this file.
  * `GET /files/{file_id}/derived-files` – Derived files produced from this file.

  **Vector database usage endpoints** return what depends on a given database:

  * `GET /vectordb/{database_id}/tools` – File search tools that reference this database.
  * `GET /vectordb/{database_id}/data-jobs` – Data jobs with this database set as the vector database.

  With the `GET /tools/{tool_id}/agents` endpoint, you can trace the full dependency chain from a file or vector database to the agents that surface it. Use these endpoints to understand usage before deleting or migrating resources, or to audit data lineage across your workflows.

  For more information, see [File usage](/flow/components/data-engine/storage#file-usage).
</Update>

<Update label="April 2, 2026" tags={["Feature"]}>
  ## Manage the full AI-ready data pipeline through a single job ID

  <ReleaseTags type="feature" />

  <SupportedOn ui={false} api={true} sdk={true} />

  The Data Jobs API and SDK introduce a unified way to manage the full AI-ready data pipeline — from file upload and ingestion through alignment — under a single job ID, replacing fragmented multi-call workflows.

  * Create and manage data jobs via REST endpoints (`/v1/flow/data-jobs`) and Python SDK helpers (`client.data_jobs.*`).
  * Attach files with automatic ingestion using accuracy- or speed-optimized modes.
  * Remove files or failed records before alignment to keep workflows clean.
  * Edit job metadata, system prompt, and vector database ID at any time.
  * Start, cancel, and monitor alignment with pre-flight validation and structured error responses.
  * Track per-file ingestion status, queue position, and suggested fixes through a single job record.
  * Supports three job types: principle files, context-grounded files, and context-grounded vector DB.
</Update>

<Update label="March 12, 2026" tags={["Feature", "Improvement"]}>
  ## Create and manage tools from Agent Builder

  <ReleaseTags type="feature" />

  <SupportedOn ui={true} api={true} sdk={true} />

  The Tool Library is now accessible from the SeekrFlow web interface, giving you a dedicated workspace to create and manage tools without writing code. Navigate to Agent Builder > Tool Library in the sidebar.

  From the Tool Library you can:

  * **Create tools** – Build File Search and Web Search tools directly in Agent Builder, including tool instructions and, for File Search, source files and search parameters.
  * **View and manage tools** – See all your tools in one place with status indicators, creation dates, and last modified dates.
  * **Inspect tool details** – Click any tool to see its full configuration, model information, and which agents are using it.
  * **Edit, clone, and delete** – Manage tools from either the list view or the tool summary panel.

  ## Trace agent responses to their sources

  <ReleaseTags type="feature" />

  <SupportedOn ui={true} api={false} sdk={true} />

  Each sentence or chunk of an agent's response is shaded to reflect how heavily it relied on retrieved context. Clicking any sentence surfaces its top contributing sources ranked by influence score. Attribution covers vector DB retrieval and web search.

  Controls for evidence depth, granularity, and influence filtering are user-configurable and persist per agent thread. Attribution can run automatically alongside a response at inference time, or be applied post-inference to any existing output.

  <Info>
    Attribution currently covers vector DB retrieval and web search tool results. Custom tools and sub-agents are not in scope for this release.
  </Info>

  ## Parallel tool execution for agents

  <ReleaseTags type="improvement" />

  <SupportedOn ui={false} api={true} sdk={true} />

  SeekrFlow agents now support parallel execution of tool plans, improving efficiency for runs that involve multiple independent tool calls. The planner can express execution dependencies between steps, so tool calls without dependencies are executed concurrently.

  **Capabilities:**

  * Planner-generated execution plans support dependency-aware step ordering
  * Independent tool calls can be executed in parallel rather than strictly sequentially
  * Executor automatically resolves execution order based on planner-defined dependencies

  This improves the efficiency of agent runs that require multiple tool invocations, particularly when steps can be performed independently.
</Update>

<Update label="February 2026" tags={["Feature"]}>
  ## Preference tuning (DPO)

  <ReleaseTags type="feature" />

  <SupportedOn ui={false} api={true} sdk={true} />

  Model alignment using direct preference optimization (DPO), training models from comparison data rather than ground truth or reward functions. Preference tuning trains models to increase the likelihood of generating preferred responses over rejected ones.

  **Capabilities:**

  * Upload preference datasets containing prompt, chosen response, and rejected response
  * Automatic schema validation on upload
  * Optional `beta` hyperparameter to control KL-divergence strength
  * Compatible with all base models supported by SeekrFlow
  * Training loss tracking identical to supervised fine-tuning

  Preference tuning supports alignment for subjective criteria like brand tone, compliance standards, and customer experience preferences where correctness is context-dependent.

  <Info>
    Preference datasets must be user-provided. The AI-ready data engine does not
    yet generate preference datasets.
  </Info>

  ## Reinforcement tuning reward functions

  <ReleaseTags type="feature" />

  <SupportedOn ui={false} api={true} sdk={true} />

  Configurable reward functions for reinforcement tuning jobs, enabling users to control which behaviors get reinforced during training. Reward functions are built from graders—individual scoring operations that can be used alone or combined into weighted, linear rewards.

  **Capabilities:**

  * Grader types: math accuracy, string check, and text similarity
  * Reward composition: single grader or weighted linear combination of multiple graders
  * Optional format reward weight to control `<think>` / `<answer>` formatting enforcement
  * Built-in weight validation and normalization

  This release also rebrands "GRPO" to "Reinforcement Tuning" in the API and SDK. Reward functions enable customers to explicitly reinforce task-specific objectives like correctness, policy adherence, or stylistic consistency, establishing the foundation for future evaluation platform capabilities.
</Update>

<Update label="January 2026" tags={["Feature"]}>
  ## Vision-language fine-tuning

  <ReleaseTags type="feature" />

  <SupportedOn ui={false} api={true} sdk={true} />

  Instruction fine-tuning for vision-language models (VLMs) that reason jointly over images and text. Users can now fine-tune multimodal models using datasets combining visual inputs and natural language through the same fine-tuning workflows used for text-only models.

  **Capabilities:**

  * Upload and validate vision-language datasets with messages-based schema and image support
  * Fine-tune supported VLMs: `Qwen2.5-VL-7B-Instruct` and `Llama-3.2-11B-Vision-Instruct`
  * Automatic schema validation and seamless job creation
  * Standard instruction tuning workflow with no separate multimodal configuration required

  <Info>
    This release supports instruction tuning only. Reinforcement learning and
    preference tuning are not yet supported for vision-language models.
  </Info>

  ## Tools library

  <ReleaseTags type="feature" />

  <SupportedOn ui={false} api={true} sdk={true} />

  Centralized workspace for managing agent tools across your organization. The tool library serves as a single source of truth where users can create, update, delete, and duplicate tools independently of agent configuration.

  **Capabilities:**

  * Create and manage web search and file search tools with custom configurations.
  * View code interpreter and custom function tools (read-only).
  * Duplicate existing tools to create variations with modified configurations.
  * Automatic propagation of tool updates to all agents using that tool.
  * Select pre-created tools during agent creation or create new tools inline.
  * Query tools by type and status, and view which agents are using specific tools.

  Tool changes automatically redeploy linked active agents to reflect updates across your organization.

  ## Ingestion insights

  <ReleaseTags type="feature" />

  <SupportedOn ui={false} api={true} sdk={true} />

  Real-time visibility into file ingestion status across Alignment and VectorDB endpoints. Every uploaded file receives its own persistent ingestion record that tracks progress through conversion, alignment, and vectorization.

  **Capabilities:**

  * Per-file status tracking (queued, running, completed, failed) with queue position and timestamps.
  * Plain-language error messages with suggested fixes.
  * Structured metadata through file\_records view showing which files are processing, completed, or blocked.
  * Consistent response schema across Alignment and VectorDB endpoints.

  This visibility layer enables faster self-service debugging and reduces support escalations during onboarding, proofs of concept, and production workflows.

  ## Multi-node fine-tuning

  <ReleaseTags type="feature" />

  <SupportedOn ui={false} api={true} sdk={true} />

  Distributed training across multiple compute nodes for improved fine-tuning performance and scalability. Multi-node fine-tuning distributes training jobs across multiple physical nodes (each with 8 GPUs), enabling parallel execution rather than single-machine training.

  **Capabilities:**

  * Support for 1–4 nodes (up to 32 GPUs total)
  * Configure node count via n\_node parameter in InfrastructureConfig
  * Automatic distributed orchestration and synchronization
  * Immediate validation of supported n\_node / n\_accel combinations

  This enables reduced training time for larger datasets, better compute allocation matching dataset size and training needs, and establishes the foundation for future support of larger models.
</Update>