> ## 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, sdkVersion = null}) => <div className="not-prose">
    <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">
      <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>
    {sdk && sdkVersion && <div className="mt-1.5 text-xs text-black/60 dark:text-white/60">
        Requires seekrai {sdkVersion}
      </div>}
  </div>;

<Update label="August 19, 2026" tags={["Deprecation"]}>
  ## Context-grounded fine-tuning sunset date extended

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

  The sunset date for context-grounded fine-tuning moved from July 17, 2026 to September 30, 2026. You can keep using it until then. For new projects, choose another [fine-tuning method](/flow/components/fine-tuning#fine-tuning-methods).
</Update>

<Update label="August 14, 2026" tags={["Improvement"]}>
  ## Follow agent execution as it happens in Agent Chat

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

  Agent Chat surfaces work as it happens rather than after it finishes.

  * Tool calls appear when they begin executing, not only once results return
  * Parallel tool calls are surfaced as running in parallel
  * Sub-agent execution is surfaced while it runs, giving visibility into multi-agent workflows that take longer to complete
  * Text streams continuously rather than arriving in large chunks

  A long-running operation is distinguishable from a stalled one.

  See [Chat with an agent](/flow/app/chat-with-an-agent).
</Update>

<Update label="August 14, 2026" tags={["Improvement"]}>
  ## More reliable sub-agent tool calls

  Tool execution runs on a model better suited to the task, resolving instability in sub-agent tool calls.
</Update>

<Update label="August 14, 2026" tags={["Fix"]}>
  ## Mermaid charts render correctly in Agent Chat

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

  Mermaid charts render without errors in agent responses.
</Update>

<Update label="August 7, 2026" tags={["Feature"]}>
  ## Review the country of origin for any model in the catalog

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

  Every model in the catalog reports a country of origin, for use in deployments with model provenance requirements. Models with no single country of origin, such as a model with a corporate parent and a development lab in different countries, report mixed origins.

  The models endpoint returns `country_of_origin` for each model. In the Model Library, each model card surfaces its country of origin, and any model that did not originate in the United States carries a warning.

  See [Country of origin](/flow/components/models#country-of-origin).
</Update>

<Update label="August 7, 2026" tags={["Improvement"]}>
  ## Create vector databases with three additional embedding models

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

  Three additional embedding models are available when you create a vector database, each with a United States country of origin.

  * `ibm-granite/granite-embedding-311m-multilingual-r2` – 768 dimensions, 32768 max input tokens
  * `ibm-granite/granite-embedding-97m-multilingual-r2` – 384 dimensions, 32768 max input tokens
  * `Snowflake/snowflake-arctic-embed-l-v2.0` – 1024 dimensions, 8192 max input tokens

  See [Embedding models](/flow/components/models/embedding-models).
</Update>

<Update label="August 7, 2026" tags={["Improvement"]}>
  ## Vector database creation uses a new default embedding model

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

  `ibm-granite/granite-embedding-311m-multilingual-r2` is now the default embedding model for vector databases. Creating a vector database without specifying a model uses the default. `intfloat/e5-mistral-7b-instruct` remains available as a selectable option.

  <Note>
    Existing vector databases keep the embedding model they were created with.
  </Note>

  See [Embedding models](/flow/components/models/embedding-models).
</Update>

<Update label="July 31, 2026" tags={["Improvement"]}>
  ## Catch fine-tuning configurations that cannot fit before a job runs

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

  Fine-tuning jobs are validated at submission. SeekrFlow estimates the configuration against the requested hardware and refuses jobs that cannot fit, instead of consuming accelerator time and failing partway through with an out-of-memory error. Memory checking covers the full configuration, including measuring dataset images for vision-language jobs. Dataset schemas and file types are validated at the same point, so malformed training files are rejected with an actionable message.

  A refused job returns a 400 with a `gpu_memory_rejection` object describing the configuration that was evaluated and the changes that would make it fit.

  <Note>
    In the Python SDK, a refusal raises `InvalidRequestError` carrying the API message.
  </Note>

  See [Create a fine-tuning job](/flow/sdk/fine-tuning/create-fine-tuning-job).
</Update>

<Update label="July 30, 2026" tags={["Improvement"]}>
  ## Faster and more consistent context attribution response times

  Context attribution requests are distributed across model replicas, and the data each request needs is retrieved in parallel. Attribution responses return faster and vary less between requests.
</Update>

<Update label="July 24, 2026" tags={["Improvement"]}>
  ## Follow training job progress through severity-tagged log entries

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

  Training job status is surfaced as a structured log of timestamped entries in the job event timeline, rather than a single status string. Processed log entries appear alongside the nine lifecycle events as **Status Update**, **Warning**, and **Error** events, with severity carried in event metadata.

  New informational messages cover details that were not visible before, including skipped document sections and dataset completion details that explain a smaller-than-expected dataset. Terminal reasons for a failed or stopped job are carried in that event's message.

  <Note>
    The status message field changes shape. Update to the current SDK for the revised typed model.
  </Note>
</Update>

<Update label="July 24, 2026" tags={["Improvement"]}>
  ## Failed training jobs explain what went wrong

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

  When a training job fails, SeekrFlow analyzes the failure logs and surfaces a plain-language explanation of the cause alongside the job, instead of a status alone.
</Update>

<Update label="July 22, 2026" tags={["Improvement"]}>
  ## Fine-tuning jobs fill in hyperparameter defaults automatically

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

  Fine-tuning jobs compute default hyperparameters for you. Omit `batch_size`, `learning_rate`, `max_length`, or `gradient_checkpointing` from a `TrainingConfig` and SeekrFlow derives each from the selected algorithm, model size, and dataset size. Set any of them to override its default. `n_epochs` remains required.

  See [Create a fine-tuning job](/flow/sdk/fine-tuning/create-fine-tuning-job).
</Update>

<Update label="July 20, 2026" tags={["Improvement"]}>
  ## Track ingestion progress for every file in a job

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

  Each file in an ingestion job reports its own progress through document conversion and vector database ingestion, so a job with one slow file is distinguishable from a job that has stalled.

  Every file record carries a confirmed progress value and a projected one, each with a timestamp. Confirmed progress moves only when a step completes, so it never goes backwards and reaches 100% only when the file is genuinely finished. Projected progress advances between confirmations, which keeps a long step such as table extraction on a large PDF from appearing frozen.

  See [Track per-file progress](/flow/sdk/data-engine/monitor-ingestion#track-per-file-progress).
</Update>

<Update label="July 20, 2026" tags={["Improvement"]}>
  ## Data job timelines report every milestone a job reached

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

  The data job timeline is driven by the timestamps of what happened, so every milestone a job reached appears in order. Jobs that stopped or were cancelled get their own terminal events, and the reason a job failed, stopped, or was cancelled is carried in the event's `metadata.status_message`.

  See [Read the timeline](/flow/sdk/data-engine/monitor-ingestion#read-the-timeline).
</Update>

<Update label="July 20, 2026" tags={["Fix"]}>
  ## Clearer errors for unsupported context attribution requests

  Context attribution returns a specific, actionable error when a request is not supported, instead of failing without explanation.
</Update>

<Update label="July 20, 2026" tags={["Deprecation"]}>
  ## Manage alignment jobs through the data jobs endpoints

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

  Alignment endpoints that duplicate data jobs functionality are deprecated in favor of their data jobs equivalents. Deprecated endpoints remain functional until **September 30, 2026**.

  * `POST /alignment/{id}/cancel` – `POST /data-jobs/{id}/cancel`
  * `GET /alignment` – `GET /data-jobs`
  * `GET /alignment/{id}` – `GET /data-jobs/{id}`
  * `POST /alignment/ingestion` – `POST /data-jobs/{id}/add-files`
  * `GET /alignment/ingestion` and `GET /alignment/ingestion/{id}` – included in data jobs list and detail responses
  * `DELETE /alignment/{id}` – `DELETE /data-jobs/{id}`

  Deprecated endpoints return `Deprecation`, `Sunset`, and `Link` response headers. The `Alignment` and `Ingestion` SDK resources emit a `DeprecationWarning` naming the `DataJobs` equivalent.
</Update>

<Update label="July 10, 2026" tags={["Improvement", "Fix"]}>
  ## Platform improvements and fixes

  This release includes the following improvements and fixes:

  * Intermittent ingestion failures caused by periodic restarts of the ingestion service have been eliminated.
  * The AI-ready data engine draws on more context when recursively summarizing long documents, improving summary quality.
  * Ingestion memory usage and processing speed have been optimized.
</Update>

<Update label="July 9, 2026" tags={["Feature"]}>
  ## Clone an existing data job

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

  Clone any existing data job into a new, editable job pre-populated from the original's configuration. The clone starts fresh as an editable job you can adjust before starting alignment, and you can give it a new name or reuse the original's. Cloning is useful for iterating on instructions or reusing a file set across related datasets.

  See [Clone a data job](/flow/sdk/data-engine/manage-data-jobs#clone-a-data-job).
</Update>

<Update label="July 8, 2026" tags={["Improvement"]}>
  ## Trace agent instructions as a context attribution source

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

  Context attribution now traces influence from a new source type, agent instructions. When a statement in an agent's response is shaped by the agent's own system prompt rather than retrieved content, attribution results surface the specific prompt segment and its influence score.

  Sources of type `system_prompt` carry the core attribution fields: `source_type`, `id`, `text`, `attribution`, and `offset`.

  See [Context attribution](/flow/components/explainability/context-attribution) for the full list of source types, or the [SDK guide](/flow/sdk/explainability/context-attribution) for the response structure.

  ## View snippets and full page content for web search sources

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

  Context attribution represents web search results under a single source type that covers both search result snippets and full fetched page content. The source text reflects what the agent retrieved, so a web search source may surface a short snippet or a longer passage.

  See [Context attribution](/flow/components/explainability/context-attribution) for source types, the [SDK guide](/flow/sdk/explainability/context-attribution) for the response structure, or [Understand a response](/flow/app/understand-a-response) for the Sources panel.

  ## Trace agent responses to MCP tool outputs

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

  Context attribution now traces influence from MCP (Model Context Protocol) tool responses. When an agent calls an MCP tool during a response, such as querying a CRM or an issue tracker, the tool's response becomes an attributable source, so you can see which integrations shaped specific statements. This includes sub-agents the agent invokes as tools, which appear as MCP tool sources.

  See [Context attribution](/flow/components/explainability/context-attribution) for the full list of source types.
</Update>

<Update label="June 26, 2026" tags={["Improvement"]}>
  ## Submit large file batches for ingestion in a single call

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

  Ingestion accepts large file batches in a single submission, including batches of 5,000 files or more. Submission time stays constant regardless of batch size. Large batches no longer need to be split into smaller ones to keep submissions responsive.

  See [Prepare and ingest files](/flow/sdk/data-engine/file-ingestion).
</Update>

<Update label="June 26, 2026" tags={["Improvement"]}>
  ## Ingest plain-text files and rely on automatic file healing

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

  The AI-ready data engine accepts plain-text (`.txt`) files for ingestion, alongside Markdown, PDF, Word, and PowerPoint. It also corrects common formatting problems automatically. Markdown files with headers deeper than six levels are accepted instead of rejected, and files with missing or malformed elements are repaired where possible.

  When a file can't be used, the job stops and names the file and the issue to fix before resubmitting. This covers a file the engine can't repair, and a file that was deleted or became unavailable after the job was created. These jobs no longer fail with a generic error that reads like a platform fault.

  See [Prepare and ingest files](/flow/sdk/data-engine/file-ingestion).
</Update>

<Update label="June 26, 2026" tags={["Feature"]}>
  ## Data jobs stop early when they can't produce useful data

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

  SeekrFlow validates each data job before it begins generating data and stops the job early when it can't produce useful results, avoiding token usage on a job that wouldn't succeed. A job is stopped when its instructions are empty, its instructions can't be interpreted as a data-generation task, its uploaded documents don't match the instructions, or no document content is relevant enough to the instructions. Each case sets a distinct `status_message` describing the cause and the adjustment to make before resubmitting. SeekrFlow also emails you when a job is stopped this way, with the job ID, source file, reason, and steps to resubmit.

  See [Monitor ingestion](/flow/sdk/data-engine/monitor-ingestion).
</Update>

<Update label="June 26, 2026" tags={["Feature"]}>
  ## Summarize the metadata in a vector database

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

  A metadata snapshot summarizes the user-defined metadata across a vector database's chunks, capturing the most common keys, their most frequent values, and each key's inferred type. Generate a snapshot to see what metadata your ingested documents carry.

  The snapshot captures up to the 100 most common keys, with up to the 10 most common values each. It refreshes automatically after an ingestion job adds documents, and can be regenerated or retrieved on demand.

  See [Generate a metadata snapshot](/flow/sdk/data-engine/generate-metadata-snapshot).
</Update>

<Update label="June 23, 2026" tags={["Improvement", "Fix", "Deprecation"]}>
  ## Guide dataset generation with data job instructions

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

  Data jobs accept an `instructions` field that describes the task your generated dataset should support. Alignment uses it to shape the examples it produces, such as the topics and the kinds of questions a fine-tuned model should be able to handle. Set instructions when you create a data job, or update them on an existing job. Data jobs no longer include a separate `description` field.

  For details, see [Create instruction fine-tuning data](/flow/sdk/data-engine/standard-instruction-finetuning) and [Manage data jobs](/flow/sdk/data-engine/manage-data-jobs).

  ## Track alignment job progress in real time

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

  The alignment job status endpoint returns richer progress data, so you can follow a running job from start to finish. Each response from `GET /v1/flow/alignment/{alignment_job_id}` surfaces the current processing step, progress through that step, overall completion, a projected completion time, estimated minutes remaining, and a human-readable status message.

  ## Platform improvements and fixes

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

  This release includes the following improvements and fixes:

  * Requesting data job outputs before a job completes now returns a clear error instead of partial results.
  * Stuck ingestion jobs restart automatically.
  * Model serving reliability and performance improvements.
  * General platform stability improvements.

  ## Context-grounded fine-tuning is deprecated

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

  SeekrFlow is deprecating context-grounded fine-tuning and will remove it on July 17, 2026. You can keep using it until then. For new projects, choose another [fine-tuning method](/flow/components/fine-tuning#fine-tuning-methods).
</Update>

<Update label="June 22, 2026" tags={["Feature"]}>
  ## Score reinforcement tuning outputs with an LLM judge

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

  Reinforcement tuning reward functions can now use an LLM grader (LLM-as-a-judge) to score candidate responses. The judge compares each response to the reference answer and rates how closely it matches in meaning and quality. This suits open-ended or subjective outputs where deterministic graders such as string check and text similarity are too rigid.

  The LLM grader takes no operation. It accepts optional generation parameters (temperature, top\_p, seed, and max\_completion\_tokens) that control how the judge produces its scores, and it combines with other graders through weights like the existing grader types.

  For details, see [reinforcement tuning](/flow/components/fine-tuning/grpo) and the [reinforcement tuning SDK guide](/flow/sdk/fine-tuning/grpo-fine-tuning).
</Update>

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

  <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

  <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

  <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 28, 2026" tags={["Improvement"]}>
  ## Control agent reasoning with effort levels and temperature

  <ReleaseTags type="improvement" />

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

  Agents support finer control over how they reason through a request.

  * `reasoning_effort` accepts `low`, `medium`, or `high`, with `medium` as the default. The `speed_optimized` and `performance_optimized` values remain supported as legacy options.
  * `temperature` controls the predictability of the agent's reasoning, accepting a value from `0` to `2` with a default of `0.6`. Lower values produce more consistent results, and higher values introduce more variation.

  See [Configure reasoning effort](/flow/sdk/agents/create-agents#configure-reasoning-effort) for details.
</Update>

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

  <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

  <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

  <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

  <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

  <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>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.