Unreleased
| Module | Change details | Link |
|---|---|---|
| Remote sandbox agent | Added SkillSandboxAgent: a subclass of AgentkitRemoteSandboxAgent that presets tool_type to Skill and defaults tool_id_env to AGENTKIT_TOOL_ID_SKILLS (falling back to AGENTKIT_TOOL_ID when unset); adds a guardrails parameter to prepend guardrail instructions to the user task, and a timeout parameter that overrides the execution timeout and adjusts the session lifetime. | Remote sandbox agent |
| Remote sandbox agent | AgentkitRemoteSandboxAgent adds a tool_id_env parameter: when set, the Tool ID is read from the specified environment variable first, falling back to AGENTKIT_TOOL_ID. | Remote sandbox agent |
| Runtime | Fixed an issue where the agent could restart its model loop while long-running tool calls were still pending in external runtimes, and an issue where events could appear out of order after session persistence: the agent now waits for pending tool results instead of restarting the model; model response event timestamps now reflect finalization time, ensuring correct ordering after database session reload; the Codex runtime includes all tool results from the current batch when resuming a thread; the PiAgent runtime preserves full conversation history and tool call/result pairing across invocations. | Runtime |
| Short-term memory | The PostgreSQL backend host field accepts host:port format: when a port is embedded in host, it takes precedence over the separate port field; the port must be in the range 1–65535. | Use PostgreSQL storage |
| Observability | Added request span and streaming TTFT telemetry: VeADK creates http_request / runner_request spans at ASGI ingress and Runner execution, and a model_request span under each LiteLLM Chat or Ark Responses SDK request. The first nonempty text, reasoning, or tool-call delta records TTFT once as gen_ai.chat_completions.streaming_time_to_first_token (floating-point seconds), also recorded once in a same-named Histogram via the global MeterProvider. Failed requests set native Span Status to ERROR with error.type. This replaces the previous custom timing fields without compatibility aliases. | Observability overview |
| Runtime | The Codex runtime adds process reuse and concurrency control: under direct + resume, same-thread Codex processes are reused by default with per-turn SDK thread/turn identity validation. New mcp_process_reuse config field and VEADK_CODEX_MCP_PROCESS_REUSE environment variable control MCP process reuse; new VEADK_CODEX_PROCESS_POOL_SIZE, VEADK_CODEX_PROCESS_IDLE_TTL_SECONDS, VEADK_CODEX_MAX_CONCURRENT_TURNS, and VEADK_CODEX_DENY_READ_PATHS environment variables control pool capacity, idle timeout, concurrency limits, and sandbox read restrictions. veadk.runtime.codex.release_codex_session and veadk.runtime.codex.shutdown_codex_runtime are provided for manual release of persistent processes. | Runtime |
| Runtime | The Codex runtime adds session isolation: under workspace_write and read_only, a VeADK-generated custom permissions profile ensures that a session’s commands cannot read or write another session’s workspace, rollouts, or configuration. turn_timeout_seconds now covers admission, setup, and the running turn. | Runtime |
| Runtime | Fixed an issue where pending tool calls could not resume in the Codex and PiAgent runtimes: previously, external runtimes could stall after pending tool calls under certain conditions; this is now fixed. | Runtime |
| Observability | APMPlus AppKey resolution adds the TENANT_APMPLUS_APPKEY environment variable as a fallback: a non-blank OBSERVABILITY_OPENTELEMETRY_APMPLUS_API_KEY is read first, then a non-blank TENANT_APMPLUS_APPKEY, and when neither is set an APMPlus token is fetched automatically using cloud credentials. Resolution is lazy and successful values are cached per APMPlusConfig instance; failures are not cached and never returned as an empty key — a sanitized error is raised instead. | APMPlus |
| Studio MPA | Adds MPA collaborating agents (A2A Center): administrators can manage the MPA-to-space binding (create, switch, unbind, delete), register collaborating agents (mutually exclusive JSON or HTTPS URL import via a single Runtime selector), manage agent aliases, members, and deletion, and view service address and skill metadata in agent details; legacy local registration endpoints are retired and return legacy_registration_retired (410) after authentication. | Studio |
| Studio MPA | Adds the MPA AGENTS.md editor: edit the selected Runtime’s AGENTS.md document from the MPA agent information rail, requiring the admin role and Runtime visibility authorization, with credentials injected by the Studio server; the document limit is 40,000 characters with revision CAS concurrency control, and older unsupported Runtimes show an upgrade message while preserving metadata viewing. | Studio |
| Studio MPA | Adds MPA container image updates: update the Runtime and Worker container images of an MPA agent independently, with three mutually exclusive sources — public tag, manual image reference, and latest resolution; the public catalog uses fixed public repositories and does not accept arbitrary repository input. Acknowledgement means submitted, not healthy, and writes are never retried automatically. | Studio |
| Studio MPA | When MPA agent creation fails, Studio shows a localized safe reason with expandable and copyable stage, operation, and optional validated error code and request ID; raw SDK, SQL, or exception text is never displayed. Known quota, authorization, timeout, and resource-state errors get matching safe explanations, and missing details are explicitly marked as unknown. | Deploy MPA agents · Studio |
| Skills | Fixed an issue where the model could fail to invoke the command-execution tool when using the legacy local skills entry due to inconsistent tool-name guidance: the generated execution guidance now uses the actual tool name, preventing the model from calling a non-existent tool due to ambiguous wording. | Skills |
| MPA deployment | When creating an MPA agent through Studio managed creation, latest image tags in the configuration are resolved anonymously to a specific published version tag in the same public repository with an identical manifest digest before deployment. The selection is persisted; retried deployments verify the saved version tag, ensuring the deployed content remains unchanged. Image publishers must retain a matching version tag alongside each latest publication and must not overwrite existing tags; deployment fails explicitly if no matching tag exists, public read access is unavailable, or the saved content has changed. Deployments using fixed version tags, existing agents, and standalone CLI deployments are unaffected. | Deploy MPA agents |
| Content safety | content_safety adds AgentSentry V3 private moderation mode: setting AGENTSENTRY_URL activates independent V3 private moderation using endpoint AK/SK signature authentication, taking precedence over TOOL_LLM_SHIELD_* configuration; it reviews only user input and the model’s visible plan before tool calls, not model output or tool results; tool calls require a visible model plan and are blocked if missing; degraded service or timeout blocks execution rather than allowing content through. Can be independently disabled via AGENTSENTRY_ENABLED. | Content-safety guardrail |
| Content safety | Added Decision backend (provider: decision): based on the Ark System One decision API, assembles content under review into state, asks configurable questions that return risk probabilities, and decides allow or block by threshold. Built-in question set covers prompt injection, credential theft, data exfiltration, dangerous operations, harmful content, and related categories; supports custom questions and thresholds; configurable via tool.content_safety block or Agent.content_safety parameter, with Runner auto-mounting the plugin. | Content-safety guardrail |
| Content safety | Added Agent.content_safety parameter and agent.content_safety_plugins property: supports configuration via None, False, True, dict, or ContentSafetyConfig; Runner resolves and mounts the corresponding plugin automatically during construction; when constructing an ADK App manually, use content_safety_plugins to obtain the resolved plugin list. | Content-safety guardrail |
| Content safety | Decision backend supports multimodal auditing: image, audio, and video parts are placed alongside text parts in original order in state, with inline media converted to base64 data URLs or using HTTPS URLs; sensitive fields and credential patterns in free text are best-effort redacted before auditing; <untrusted> tags are escaped to prevent content from forging the wrapper. | Content-safety guardrail |
| SSE | Fixed an issue where SSE streaming output could have duplicate or missing event IDs: SSE payload generation now assigns unique event IDs to partial events, empty-ID events, and already-emitted ID events, preventing clients from dropping events due to ID collisions. | Runtime |
| Observability | APMPlus metrics add skill download and load counters: gen_ai_skill_download_count counts skill package acquisitions (including cache hits and failures) and gen_ai_skill_load_count counts successful skill instruction loads; both are OTEL counters with unit 1 and dimensions skill_source, skill_id, skill_name, skill_version, and skill_space_id. A download_skill {skill_name} span annotates skill source, ID, name, version, space, consumer, outcome, and cache-hit attributes; the outcome is recorded only on the span, not as a counter dimension. On successful skill instruction load, the existing tool span is renamed to load_skill {skill_name} and annotated with the corresponding identity attributes. | APMPlus |
| Studio code-package deployment | Code-package upload adds deployability validation: rejects __pycache__/, *.pyc, and binary files; requires app.py and requirements.txt at the root when no Dockerfile is present, failing the upload if missing; shows a warning when no 0.0.0.0:8000 or PORT service listener is detected. | Studio |
| Runtime | Added runtime="dsh": drives the agent inner loop through the DeepSeek Harness SDK. The dsh binary is installed with veadk-python[dsh] and the subprocess starts lazily at runtime without a first-run download. One effective configuration reuses the SDK object and subprocess; VeADK session history serves as the short-term memory source. ADK function tools, MCP tools, sub_agents transfers, and SkillToolset are bridged through DSH native plugins and a skill loader; root-session streaming output maps to ADK partial events. Supports provider aliases (openai, volcengine, volcengine-ark, ark, openai-compatible, third-party) mapped to the deepseek-official adapter; generates a process-isolated dsh_home when not configured. Configurable via deepseek_harness_runtime_config or VEADK_DEEPSEEK_HARNESS_* environment variables. | Runtime |
| Dependencies | Added optional dependency group dsh (alias deepseek-harness): installs deepseek-harness-sdk==0.1.5rc1 and its transitive dependency deepseek-harness-runtime-bin, providing the dsh executable. | Runtime |
| Skills | Harness selected_skills adds source: tos to load skills from TOS object storage: use tos_url to specify a private directory at tos://<bucket>/<prefix>/ (downloaded with the current account’s cloud credentials; the directory root must contain SKILL.md), or use tos_public_url to specify a public TOS zip HTTPS URL (no AK/SK required; must point to a .zip file on a TOS public endpoint). Each entry loads one skill; downloads are bounded by file count and size limits, and TOS references are redacted in load-failure errors. | Skills · Harness deployment |
| Observability | The in-memory exporter’s local span retention is now bounded: the most recent 1024 spans are retained by default with an estimated data cap of 16 MiB; the oldest span is evicted when either limit is reached. A single span exceeding the byte limit is not retained locally but is still forwarded to configured cloud exporters. New environment variables OBSERVABILITY_OPENTELEMETRY_INMEMORY_ENABLED, OBSERVABILITY_OPENTELEMETRY_INMEMORY_MAX_SPANS, and OBSERVABILITY_OPENTELEMETRY_INMEMORY_MAX_BYTES control local retention behavior. Multiple tracers under the same TracerProvider now share a single in-memory exporter instance. | In-memory exporter · Overview |
| Runtime | The Codex runtime adds a model_transport configuration: direct mode lets Codex call the model endpoint’s Responses API directly, with ADK tools served to Codex over an in-process MCP bridge so Codex drives the tool loop; shim mode routes through a Responses-to-chat shim that runs the tools; auto selects direct for endpoints known to serve the Responses API. Override with the VEADK_CODEX_MODEL_TRANSPORT environment variable. | Runtime |
| Runtime | The Codex runtime adds a thread_mode configuration: resume keeps one Codex thread per session, resumed on the next turn instead of replaying a transcript; ephemeral starts a fresh thread every invocation. Only the direct transport supports resume. Override with the VEADK_CODEX_THREAD_MODE environment variable. | Runtime |
| Runtime | The Codex runtime adds a turn_timeout_seconds configuration: sets an upper bound for one Codex turn; the turn is interrupted and the invocation fails on timeout, preventing a long-running turn from blocking later session calls. | Runtime |
| Runtime | The Codex runtime adds an auto_compact_token_limit configuration: sets the token threshold at which Codex compacts the thread history itself (direct transport only). | Runtime |
| Runtime | Added Runner.steer(session_id, text): inserts an additional instruction into the currently running Codex turn so the agent adjusts course without starting a new turn. Only the direct transport supports it. | Runtime |
| Dependencies | The openai-codex dependency is upgraded from 0.1.0b3 to 0.159.2; the SDK now pins its matching CLI binary, so openai-codex-cli-bin is no longer listed separately. | Runtime |
| Studio deployment | Fixed deployment validation for A2A registry (remote-agent) nodes: remote-agent nodes configure discovery on their parent agent and do not require a local agent name; they can be added or retained during a standard Runtime update without enabling Sidecar or configuring MCP. Source-preserving updates still require the original agent structure (including sub-agents and A2A registry nodes) to be preserved. | Studio agent workbench · Studio agent workbench |
| Studio deployment | Deployment validation now reports problems by category — agent name or structure, skill files or configuration, MCP configuration, and source-image registry — each with a specific, actionable error message. | Studio agent workbench |
| Observability | APMPlus metrics now include a cache_read token dimension: when the model returns cache hit information, the cached input token count is recorded separately as cache_read, representing a subset of input rather than additional usage; the previously incorrect cache creation token attribute has been removed. | APMPlus |
| Studio evaluation | Evaluation sets and samples are now stored in Studio persistent storage (TOS) instead of using AgentKit evaluation APIs. Conversation thumbs-up/thumbs-down feedback and automatic evaluation cases use the same TOS records; evaluation data is scoped by Runtime ID and does not depend on app name, project, or region. Feedback is now supported on BytePlus deployments (requires TOS configuration). | Studio agent workbench |
| Studio deployment | When creating a new Runtime, the minimum and maximum instance limits are set during creation instead of being updated separately afterward. After deployment, Studio waits for the configured number of instances to become ready before reporting success, preventing the first conversation from landing on a temporary startup instance. | Studio agent workbench |
| Studio deployment | veadk studio deploy and veadk studio update now stream real-time VeFaaS release progress in the terminal: the code upload phase shows a progress bar (percentage, speed, and ETA), and the release phase shows release status, revision, build stages (installing dependencies, building image, deploying service, starting service), and elapsed time. Build logs are printed as they become available with repeated lines suppressed; during quiet periods a stage progress message is emitted every 15 seconds. Logs are redacted of credentials before output. The scheduled-task scanner and worker Functions each show independent deployment progress and build logs. | Studio agent workbench |
| Studio deployment | New deployments of Studio itself default to 8 vCPU, 16 GB memory, and one instance on both Volcengine and BytePlus. Agent Runtimes created inside the workbench keep their project deployment settings. | Studio deployment |
| Studio migration | The migration workspace is now a single-column layout without side navigation. The home page shows the upload entry at the top, followed by recent migrations in a table (five entries by default, expandable in place); expired migration environments are offered as view-only. “Migrated projects” is now a top-bar entry. Returning home or opening the project library never stops a running migration. Capability and session-list load failures are reported separately so the upload entry stays usable, and each failure offers its own retry. | Studio agent workbench |
| Studio model selection | The API Key list is now read live from the cloud provider on each page load without server-side caching of key metadata. Each API Key shows its status (Enabled/Disabled) and permission scope (All permissions/Custom permissions); disabled keys remain visible but cannot be selected. Search supports matching multiple keywords against names, statuses, and permission scopes. | Studio agent workbench |
| Studio model selection | When an API Key with custom permissions is selected, models outside the permitted scope remain visible but are disabled and annotated with the reason (not permitted, shut down, video generation, not a chat model, or not activated). Video generation and shut-down models explicitly granted by the API Key also appear but remain disabled. Switching API Keys automatically clears models and fallback models no longer permitted by the new key. Overlapping requests share a single cloud query, and permissions are recomputed for the current key. | Studio agent workbench |
| Built-in tools | Added BashToolset, a read-only filesystem toolset providing ten commands — cat, pwd, ls, find, grep, head, tail, wc, stat, diff — implemented with the Python standard library. It supports configurable permissions including working directory, allowed directories, exclusion patterns, and resource limits, suitable for agents that need to safely read and search local files. | Bash Toolset |
| Studio tools | Added session artifacts: when the studio_write_artifact tool is enabled in a conversation that supports Studio tools, the agent can save generated reports, charts, documents, and other output as UTF-8 text files that become artifacts of the current session; a “Session artifacts” panel above the chat composer lets users browse a file tree, preview (HTML, Markdown, images, JSON, text), and download artifact files. | Studio agent workbench |
| Studio automation | Added GitLab MR automated review: connect a user account via GitLab OAuth, select target projects and enable review, then non-draft MRs in those projects automatically trigger isolated Sandbox review tasks with results published as GitLab Discussions and comments. Administrators configure the GitLab OAuth application and Webhook Secret via environment variables. | Studio agent workbench |
| Studio update | veadk studio update now supports a --skip-cronjob-scheduler flag to skip the scheduled-task scheduler update and update only the main Studio Application. | Studio agent workbench |
| Studio project generation | The veadk-python version pinned in the requirements.txt generated by quick create mode is updated from 1.1.11 to 1.1.13. | Studio agent workbench |
| Studio chat history | Fixed a bug where assistant replies could be misaligned with their corresponding user messages when viewing conversation history with multiple user and assistant turns. | Studio agent workbench |
| Studio intelligent development | Fixed a bug where the previous deployment page navigation state was not cleared when re-entering intelligent development from the create entry: re-entering previously landed on the previous deployment page; it now returns to the home page and clears the deployment navigation state. Saved project versions can still be selected from the version library for redeployment. | Studio agent workbench |
| Inbound authentication | OAuth2Config.from_veidentity() now accepts a client_secret parameter: when paired with client_uid, it skips the client lookup during startup, reducing startup overhead. | Inbound authentication |
| Studio MCP credentials | Simplified MCP tool credential editing: removed the credential reuse confirmation step after changing a service URL; the Token input is always editable with a show/hide toggle; MCP credentials submitted during debug testing are also applied to the deployment runtime environment. | Studio agent workbench |
| Knowledge base | The VikingDB knowledge base backend adds an api_key parameter and the DATABASE_VIKING_API_KEY environment variable: when set, knowledge search uses API key auth, enabling search on existing collections without AK/SK or IAM credentials. When AK/SK is not configured, collection management precheck is skipped; creating, deleting, listing collections, and file upload still require AK/SK or IAM credentials. | Use VikingDB storage |
| Long-term memory | The VikingDB memory backend adds an api_key parameter and the DATABASE_VIKINGMEM_API_KEY environment variable: when set, memory read and write operations use API key auth, enabling access to existing collections without AK/SK or IAM credentials. When AK/SK is not configured, collection management precheck is skipped; creating, listing, and deleting collections still require AK/SK or IAM credentials. | Use VikingDB storage |
| A2A | When calling downstream agents via the AgentKit A2A Registry, VeADK now supports parsing A2A 1.0 AgentCards: when the AgentCard does not provide a top-level url field, the endpoint is resolved from supportedInterfaces by protocol binding type and version, preferring JSONRPC bindings with protocol version 1.0. | Inbound authentication |
| A2A | When the downstream AgentCard declares a credential provider in capabilities.extensions, VeADK automatically retrieves the managed API Key from the identity service and constructs the authentication header, requiring no manual API Key configuration on the VeADK side. | Inbound authentication |
| Frontend component preview | The component preview page is reorganized into Foundation, Base, Block, AI App, Node, and Layout groups, sorted by component name within each group. Foundation adds a frontend development specification page. Each component page provides an in-page table of contents with #component/section links for jumping to variant sub-sections and the parameter table. | VeADK Frontend |
| Frontend chat | The long-running task progress component (LongRunningState) is redesigned as a left-aligned single-column layout showing the current progress name, a cyclic loading bar, and a content area in sequence. The progress name fades up and slides in on change; the animation stops on completion and preserves the last result. Supports reduced-motion preference. | VeADK Frontend |
| Frontend chat | The conversation flow component (ConversationFlow) now expands space for newly appended steps before fading in their content. Status updates and expanding historical details do not replay the entrance animation. Reduced-motion mode shows content immediately. | VeADK Frontend |
| Skills | Added the SKILL_SPACE_POLICY environment variable to filter skills loaded from cloud skill spaces by skill ID: mode set to allow loads only the specified skills, while deny excludes them; a malformed policy disables all cloud skill loading. When set, the policy is automatically forwarded to sandbox sessions created by execute_skills, invoke_skill, poll_skill, and run_sandbox_agent. | Skills |
| Skills | The SKILL_SPACE_POLICY environment variable now supports a per-space policy format: use a spaces.<space_id>.mode and spaces.<space_id>.ids structure to configure separate filters for each skill space; spaces not listed are not filtered. Harness selected_skills adds a skill_space_policy field for per-space filtering on skillspace-source entries; when set, it takes precedence over the SKILL_SPACE_POLICY environment variable. | Skills · Harness deployment |
| Cloud deployment | CloudApp’s A2A communication with deployed agent endpoints now selects HTTP proxies following the VeFaaS SDK convention: it reads the scheme-matching environment variable (HTTPS_PROXY/HTTP_PROXY, uppercase preferred) and no longer uses ALL_PROXY, NO_PROXY, or system proxy settings. Environments that previously relied on ALL_PROXY must switch to the proxy variable matching the endpoint scheme. | Studio agent workbench |
| Skills | Fixed a bug where child processes were not cleaned up when a skill shell script timed out or was cancelled: on timeout or cancellation the entire process group (including processes spawned by the script) is now terminated, with up to 5 seconds for cleanup, preventing orphaned processes. | Skills |
| Studio update | veadk studio update now adds --extra-index-url https://pypi.org/simple to the staged dependency requirements file when updating with --provider byteplus, allowing pip to fall back to the public PyPI index when packages are unavailable from the BytePlus default package index, preventing update failures caused by missing packages. This aligns the update command with the existing behavior of veadk studio deploy. | Studio agent workbench |
| Studio models | The default Volcengine model used by the Studio Sandbox Tool is updated from doubao-seed-2-1-pro-260628 to doubao-seed-2-1-pro-260915; the intelligent-development and migration model allowlist is updated accordingly, adding deepseek-v4-1-flash-260910. | Studio agent workbench |
| Studio migration | Migration execution progress is now pushed through a live event stream that reconnects automatically on connection loss and resumes the progress display; the panel header shows a live status label for the current migration phase (analyzing the project, running the migration, verifying the migration, packaging the migration, reviewing the delivery). | Studio agent workbench |
| Studio migration | When Codex needs user input during migration, a pending question is shown in the “Codex activity” panel; the user’s answer continues the current step without restarting it. | Studio agent workbench |
| Knowledge base | The OpenViking knowledge base context search no longer forwards the session parameter; only session_id is used for session identification. Adapted to the OpenViking SDK options API; the minimum openviking-sdk version is raised to 0.1.9. | Use OpenViking storage |
| MPA Agents | When deleting an MPA Runtime, Studio first cleans up the agent’s exclusive cloud resources (such as Worker templates) before deleting the Runtime itself. Resource ownership is verified through registry records and runtime environment variables to prevent deleting resources not owned by the instance. Active operations and session bindings are checked before deletion; active operations block deletion. | Deploy MPA Agents · Studio agent workbench |
| MPA Agents | OpenViking preparation adds an automatic mode: new Beijing-region requests automatically create an independent OpenViking collection using default VLM and Embedding models, without requiring manual service URL and API Key entry. Enable via managed.openviking.mode: auto in YAML; manual mode remains compatible. BytePlus also supports automatic OpenViking creation. The OpenViking collection is a paid retained resource and is not removed when an MPA is deleted. | Deploy MPA Agents |
| MPA Agents | New MPA agents default to an independent business Workspace: each agent uses a dedicated business database (aidb), configured via managed.postgres.business-workspace-mode: per-agent and managed.postgres.business-database-name: aidb. Omitting both options retains the shared business database layout. | Deploy MPA Agents |
| MPA Agents | TOS output storage adds an IAM Role mode: when creating MPA agents in Studio, only an existing bucket beginning with agentkit-platform- is selected; no TOS AK/SK is required. Creation adds a bucket-specific policy to the Worker Tool role. Enable via managed.worker.tos-credential-type: iam_role in YAML. Historical AK/SK mode remains compatible. | Deploy MPA Agents |
| MPA Agents | Runtime name availability is now pre-checked before creating an MPA agent: the name is checked against existing Runtimes and Worker templates before provisioning resources, preventing creation failures from name collisions. | Deploy MPA Agents |
| MPA Agents | BytePlus MPA creation adds automatic APM AppKey injection: deployment credentials call GetAppKey to obtain the APM AppKey and inject it into the Runtime environment variable OBSERVABILITY_OPENTELEMETRY_APMPLUS_API_KEY, along with the OTLP export endpoint. veadk studio deploy automatically sets VEADK_MPA_BYTEPLUS_CREDENTIAL_FILE to the mounted IAM credential file. | Deploy MPA Agents |
| MPA Agents | Runtime role preparation now automatically retries IAM transient failures (timeout, connection, throttling, service unavailable) up to four times with increasing waits; permission denied and ownership conflicts fail immediately. | Deploy MPA Agents |
veadk mpa command group: supports one-click provisioning of prerequisite resources (network, APIG, PostgreSQL, Skill Space, Worker) and deployment of MPA agents to AgentKit Runtime without checking out agentkit-mpa-agent source. Includes provision (YAML config deployment), create (CLI creation), init-admin-db (management database initialization), and control (control-plane lifecycle management) subcommands. | Deploy MPA Agents |
| Studio | Studio supports MPA agent managed creation: select “MPA Agents → Create MPA Agent” to enter a three-step creation flow that automatically reuses the deployed Studio’s user pool and callback URL, using built-in Beijing region default images and models, with PostgreSQL auto-provisioning and automatic OpenViking creation. | Studio agent workbench · Deploy MPA Agents |
| Dependencies | Minimum agentkit-sdk-python version raised from 0.8.0 to 0.8.5. | Installation |
| Dependencies | google-adk dependency narrowed from >=1.34.0 to >=2.7.0,<2.8.0; google-adk[eval] updated accordingly. Environments using google-adk 1.x or 2.x versions outside 2.7.x must upgrade to 2.7.x. | Installation |
| Dependencies | opentelemetry-exporter-otlp version constraint changed from ==1.37.0 to >=1.37.0,<1.43; opentelemetry-instrumentation-logging adds <0.64 upper bound. | Installation |
| Dependencies | tos adds <2.9 upper bound: TOS 2.9.x pins wrapt 1.16.0, conflicting with VeADK’s wrapt version. | Installation |
| Dependencies | jsonschema version constraint narrowed from >=4.23,<5 to >=4.23,<4.24: litellm pins jsonschema 4.23.0. | Installation |
| Dependencies | fastmcp adds <4 upper bound: fastmcp 4.x requires mcp>=2, incompatible with the current mcp version. | Installation |
| Dependencies | agentkit-sdk-python in the harness-sidecar extra changed from >=0.8.1,<0.9.0 to >=0.8.5, removing the upper bound. | Installation |
1.1.26
VeADK 1.1.26 was released on November 6, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Skills | Fixed downloading skills from cloud skill spaces when the returned storage path is a signed HTTPS TOS URL or when direct object-key download is denied: signed HTTPS TOS addresses are now downloaded directly; when direct download fails, the materializer automatically requests a temporary download URL and retries. | Skills |
| Content safety | Fixed AgentSentry V3 private moderation decision handling: for successful responses, content is blocked only when the decision type normalizes to BLOCK (value 2); PASS (value 1), other values, or decisions that cannot be converted to an integer allow content through, no longer blocking on the degraded flag or unknown decisions. Only API errors, non-200 status codes, and timeouts return a service-unavailable message. | Content-safety guardrail |
1.1.13
VeADK 1.1.13 was released on September 15, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Studio deployment | VeFaaS release failure diagnostics are now structured: linked FaaS data plane logs are extracted from the release output and downloaded, then displayed alongside control plane logs and the final status in separate sections. Error messages are localised by cloud provider — Volcengine mode shows Chinese, BytePlus mode shows English. | Studio agent workbench |
| Studio project generation | The veadk-python version pinned in the requirements.txt generated by quick create mode is updated from 1.1.10 to 1.1.11. | Studio agent workbench |
| Model | When using a non-native model interface, the automatic 429 rate-limit retry no longer deep-copies tool objects in the request, fixing a failure that could occur with custom function tools carrying non-serialisable state such as thread locks. | Model |
1.1.12
VeADK 1.1.12 was released on September 14, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Studio deployment | veadk studio deploy now adds --extra-index-url https://pypi.org/simple to the staged dependency requirements file when deploying with --provider byteplus, allowing pip to fall back to the public PyPI index when packages are unavailable from the BytePlus default package index, preventing deployment failures caused by missing packages. | Studio agent workbench |
| Studio intelligent development | The model selector in intelligent development and existing-project migration now shows only models that the current cloud provider allows for intelligent development. Volcengine and BytePlus each maintain an independent development model allowlist; models outside the allowlist do not appear in the selector and are not accepted as the default model for intelligent-development or migration sessions. | Studio agent workbench · Studio agent workbench |
| Studio migration | Migration effect evaluation scores are now deterministic: each raw dimension score is rounded half up to a 0–100 integer before aggregation. Case scores and dimension averages are computed from those integers, and the overall score is the average of rounded dimension averages. Each average rounds half up and excludes N/A values, ensuring that scores at every level are consistent with report validation and lowest-scoring case rankings. | Studio agent workbench |
| Studio intelligent development | During quiet periods, the intelligent-development stream sends a heartbeat every 15 seconds to keep the connection alive without resetting Codex’s inactivity timeout. When a Codex turn is interrupted — including interruptions discovered after reconnecting — Studio reports the interrupted status explicitly; it does not publish a new version or wait for the inactivity timeout. Active turns resume on the same Thread after a connection drops; new task progress resets the recovery allowance, while reconnecting and reading unchanged state do not extend the inactivity deadline or restart the task. | Studio agent workbench |
| Studio Codex sessions | Built-in Codex sessions recover the transport automatically and continue the current Thread after a connection drops. Transport recovery does not reset the inactivity timeout; new progress during an active turn resets the recovery allowance, while reconnecting and reading unchanged state do not extend the inactivity deadline. Explicit stop requests, inactivity timeouts, task cancellation, and transport failures have distinct reason identifiers; cancellation alone does not imply a user-initiated stop. | Studio agent workbench |
| Studio deployment | In BytePlus deployments, the Studio-generated requirements.txt now includes --extra-index-url https://pypi.org/simple, allowing packages unavailable from the BytePlus default index to be fetched from PyPI, improving dependency installation reliability. | Studio agent workbench |
1.1.8
VeADK 1.1.8 was released on August 31, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Studio automation | The GitHub automations (template project import, AgentKit Runtime continuous delivery, and PR automated review) now support the BytePlus cloud provider: the region options, default region, default model API URL, and required GitHub Secret names follow the current cloud provider — Volcengine mode uses cn-beijing and VOLCENGINE_* Secrets, while BytePlus mode uses ap-southeast-1 and BYTEPLUS_* Secrets. Generated workflows now write the CLOUD_PROVIDER and AGENTKIT_CLOUD_PROVIDER environment variables; in BytePlus mode the continuous delivery workflow additionally injects the BytePlus credential mapping and the memory-region environment variables. | Studio agent workbench |
| Runtime | Added RuntimeProvider, DispatchRuntimeProvider, LocalRuntimeProvider, and ToolCall: working as ADK plugins, they intercept before a tool call executes and decide where each tool call runs, without changing the model reasoning loop. DispatchRuntimeProvider dispatches selected non-MCP tools to a remote runtime while all other tools fall back to their local implementation; MCP tools always retain their original implementation. | Runtime |
| Short-term memory | ShortTermMemory adds an after_create_session_callback parameter: a synchronous or asynchronous callback invoked after a new session is created, receiving the new Session; not invoked when an existing session is reused. | Overview |
| Dependencies | Added a sandbox optional dependency group containing the Anthropic SDK, python-dotenv, and httpx[socks], used by the self-hosted sandbox example. | Installation |
| Content safety | content_safety adds support for the Lumen Moderate endpoint: when TOOL_LLM_SHIELD_URL is set to an address whose path contains /OpenTOP/V1/Lumen/Moderate, moderation requests are sent to that endpoint and authenticated with the AppID as the endpoint identifier and the API key as the endpoint secret; tool-call reviews attach the current session and invocation identifiers. The default firewall endpoint behavior is unchanged. | Content-safety guardrail |
| Studio chat | In cloud mode, after connecting a Runtime and sending a message, a “View logs” entry appears below the composer that opens an “Instance logs” panel streaming the live logs of the VeFaaS instance handling the current conversation request: it shows connection status, instance ID, console link, and request ID, auto-refreshes and keeps the most recent 1,000 lines, colors lines by log level, supports auto-follow and error retry, and logs are credential-redacted and length-truncated on the server. | Studio agent workbench |
| Studio creation | Custom creation now supports a “quick create” mode: when enabled, the generated agent project includes the CreateAgentToolset dynamic agent delegation toolset, allowing the main agent to collect resources, create sub-agents, and delegate execution at runtime. In quick mode requirements.txt pins veadk-python 1.1.7 and includes a compatibility module. | Studio agent workbench · Dynamic agent delegation |
| Studio deployment | When deploying a quick-create agent to AgentKit, if the Runtime uses a Studio-generated default service role, Studio automatically attaches the AgentKitFullAccess policy to that role so sub-agents can access AgentKit resources; custom service roles are not modified. | Studio agent workbench |
| Dynamic agent delegation | CreateAgentToolset adds an offline mode: when the user explicitly prohibits network, knowledge-base, or external-resource access, the main agent can skip collect_resources and pass an empty string as collection_id, with sub-agents relying solely on their own model capabilities. | Dynamic agent delegation |
| Dynamic agent delegation | create_agents is now idempotent: results for the same request fingerprint are cached, and each collect_resources result requires only one create_agents call that includes all required sub-agents. Resource snapshots use a bounded cache (up to 128) and are not invalidated after being read. | Dynamic agent delegation |
| Dynamic agent delegation | Blueprint fields now include reusable identity and task separation guidance: name, id, description, and instruction should describe a stable, reusable capability domain, while task is the sole carrier of the current one-off objective. Task context is automatically appended to LLM node instructions at runtime. | Dynamic agent delegation |
| Studio deployment | veadk studio deploy treats VeFaaS deployments as idempotent by application name: deploying again with the same --vefaas-app-name updates the existing application’s function code bundle instead of creating a duplicate function. | Studio agent workbench |
| Studio project generation | The default veadk-python version in generated project requirements.txt is updated from 1.1.6 to 1.1.7. | Studio agent workbench |
1.1.7
VeADK 1.1.7 was released on August 30, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Built-in tools | Added the CreateAgentToolset dynamic agent delegation toolset: the main agent calls collect_resources at runtime to gather skills, knowledge bases, and VeADK built-in tools and to search the public Skill Hub with task keywords, then calls create_agents to build one or more sub-agents from blueprints and transfer the task via transfer_to_agent. Sub-agents share the same session context and produce the final answer directly. Supports llm, sequential, parallel, and loop nodes, plus workflow nodes on Google ADK 2.0.0 and above. LLM nodes can explicitly mount resource refs and trusted Python tools. | Dynamic agent delegation |
| Studio storage | When using Volcengine as the cloud provider without a custom TOS endpoint, Studio probes the default public endpoint on first access and automatically falls back to the corresponding intranet endpoint (tos-<region>.ivolces.com) on transport-level network errors, using the selected endpoint for all subsequent requests. Authentication failures, permission errors, and other non-network TOS service errors do not trigger fallback. Browser-facing signed URLs always use the public endpoint. BytePlus and custom endpoints are unaffected. | Studio agent workbench |
| Studio updates | Updating a deployed agent now supports a source-preserving update mode: the deployed image is kept unchanged, and only the edited configuration (agent draft, skills, and MCP credentials) is published as an overlay on top of the existing image, without rebuilding the image. Studio selects this mode automatically based on the Runtime’s current state; publication is faster and existing skills in the image are preserved. | Studio workspace |
| Studio updates | For Runtimes deployed before the update capability was introduced, Studio can now recover the agent configuration (including MCP tools and skill files) from the deployed image and runtime environment, enabling updates for these older deployments. Recovery requires the Studio runtime identity to have read-only access to the container registry hosting the image. | Studio workspace |
| Studio deployment | Updating a Runtime now includes pre- and post-publish safety checks: before publishing, Studio verifies that the Runtime version and image identity match what was loaded during editing; after publishing, it confirms the version incremented and the status is Ready, preventing concurrent modifications from overwriting the live configuration. When a deployment task is already in progress on the same Runtime, new requests are rejected with a prompt to wait for completion before retrying. | Studio workspace |
| Studio deployment | The deployment progress stream now includes heartbeat keepalive messages during long builds to prevent proxies or browsers from timing out on idle connections. | Studio workspace |
| Runtime | ADK model callbacks (before_model_callback, after_model_callback, on_model_error_callback) and the same-named methods on ADK plugins now run in external runtimes such as codex and piagent; previously only the default ADK runtime executed these callbacks. before_model_callback can mutate the request (conversation contents, system instruction, output schema, tools) and return a response to short-circuit the turn; after_model_callback runs after the final text response; on_model_error_callback runs on model-call errors and can return a fallback response. | Runtime |
| Runtime | output_key now works across all runtimes, including external runtimes such as codex and piagent; previously the final response was only written to session state when using the default ADK runtime. | Runtime |
| Long-term memory | Agent adds an auto_save_memory_policy parameter (default "default") that controls which events are written to long-term memory during auto-save. It supports three presets — "default", "all", "custom" — and can also be configured via the MemoryAutoSavePolicy class to filter by role, author, and event type. add_session_to_memory now accepts the same auto_save_memory_policy keyword argument. Auto-save is now incremental: each save only persists events that are new since the last save. | Long-term memory |
| Studio workspaces | The Studio sidebar adds a “Workspaces” entry for organizing reusable runtime environments into workspaces by purpose. A workspace can contain multiple environments, and the same environment can belong to multiple workspaces; deleting a workspace only removes the association without deleting the environments. Environments referenced by workspaces cannot be deleted directly. | Studio agent workbench |
| Studio runtime environments | Adds an “Environments” page for creating, managing, and building reusable runtime environment images. Each environment includes an operating system, Python version, command-line tools, skills, and a Dockerfile; after building, it produces a container image selectable as the base image when deploying an agent. Supports Ubuntu 22.04/24.04, Python 3.10/3.12, and command-line tools including lark-cli, pandoc, opencli, uv, ripgrep, jq, GitHub CLI, Playwright, Chromium, Git, curl, FFmpeg, and ImageMagick. | Studio agent workbench |
| Studio runtime environments | Creating a runtime environment now offers an “Upload Dockerfile” creation method: you can upload an existing Dockerfile file directly (via drag-and-drop or file picker, up to 128 KiB) and continue editing the content after upload. The uploaded Dockerfile must be non-empty and contain a FROM instruction. This method does not configure operating system, tools, or skills; those are determined by the uploaded file content. | Studio agent workbench |
| Studio creation | The Environment step in custom creation now lets you select a base image from successfully built runtime environments, or use the default AgentKit runtime environment; previously it required directly selecting command-line tools and editing the Dockerfile. | Studio agent workbench |
| Studio deployment | veadk studio deploy adds --environment-cp-workspace and --environment-cr-repository flags to specify existing CodePipeline workspace and Container Registry repository for environment image builds; when omitted, managed resources are created or reused. | Studio agent workbench |
| Studio chat | When sending a message or running a test agent, if no first streaming event arrives within 30 seconds, Studio now aborts the stream and prompts you to check shared public egress network configuration and retry, preventing the request from hanging indefinitely. | Studio agent workbench |
| Model credentials | When resolving a Volcano Ark API Key by name (MODEL_AGENT_API_KEY_NAME), transient Ark service errors (throttling, timeouts, internal errors) are now retried a limited number of times before failing, preventing occasional service fluctuations from causing credential resolution to fail immediately. | Model |
| Studio debug | Cloud-deployed Studio (running on VeFaaS) now validates MCP and A2A endpoint addresses during debug runs: only private endpoints within the VPC attached to the Studio function are allowed; private addresses outside that VPC, loopback addresses, link-local addresses, and cloud metadata addresses are blocked. Locally started Studio is unaffected. If the VPC ranges cannot be determined, the debug run fails with guidance to check VPC configuration and IAM permissions. | Studio agent workbench |
| Studio migration | The “Codex activity” panel is improved: the first incomplete plan step is automatically marked as in progress, command execution and file update activity items use consistent titles, and activity items that fail are automatically expanded to show error details. | Studio agent workbench |
| Studio migration | The migration model selector now excludes models incompatible with project migration; creating a migration task with an incompatible model fails with guidance to choose a different model. | Studio agent workbench |
| Studio packaging | The veadk-python package now includes all frontend runtime modules and validates wheel completeness when building Studio from source; previously some frontend modules were missing, which could cause import errors during veadk studio deploy --from-source or veadk studio update. | Studio agent workbench |
| Studio tracing | When displaying model output in the trace panel, empty placeholders (null entries) produced during streaming progression are now automatically removed, showing only the actual content parts. | Studio agent workbench |
| Studio evaluation | When the account has no existing evaluation datasets, creating the first feedback and automatic evaluation datasets no longer fails due to the absence of a pre-existing workspace; Studio now creates the first dataset directly under the project and resolves the workspace from it, reusing the workspace for subsequent operations. | Studio agent workbench · VeADK Frontend |
| Studio UI | The agent directory, resource library, cron jobs, environment center, and other pages are unified into a consistent resource collection layout with shared card, search, filter, and pagination components. The agent directory adds owner (“All”/“Created by me”) and region filters, agent type labels are simplified (e.g., “Codex agents” becomes “Codex”), and creation times are displayed as relative labels. | Studio agent workbench |
| Studio intelligent development | Intelligent-development sessions no longer appear in the sidebar history list and can no longer be deleted from the sidebar. Sessions run in the current browser session and can be resumed after switching pages; navigating away during a build prompts that leaving will stop the current build, but the session is preserved. | Studio agent workbench |
| Studio intelligent development | The intelligent development creation page adds a model selector, letting you specify the model Codex uses when creating an intelligent-development session. The model list comes from Ark models activated under the current account, defaulting to the model configured on the Dev Sandbox Tool; the selected model configuration is injected into the session environment by the Studio server without sending credentials to the browser. The intelligent development entry now also validates that model credentials are configured on the Dev Sandbox Tool; when not configured, the entry is unavailable and prompts you to redeploy Studio. | Studio agent workbench |
| Studio message feedback | Fixes a duplicate JSON request header issue when Studio forwards runtime requests: previously, forwarded requests could carry duplicate Accept and Content-Type headers, causing some runtimes to treat the request body as non-JSON and fail to parse it, which could cause message feedback and evaluation write operations to fail. | VeADK Frontend · Studio agent workbench |
| Studio agent directory | Each Runtime card in the agent directory now checks whether the Runtime supports Studio conversation before allowing connection: while the check is in progress, a “Checking” status is shown and the Connect button is disabled; when the check does not pass, an “Unsupported” or “Check failed” label is shown with a Retry button. Results are cached per Runtime version and automatically re-checked when the version changes. | Studio agent workbench |
| Studio agent details | When loading agent info or Runtime details fails, the detail panel now shows the error message and provides a Retry button to reload the corresponding content. | Studio agent workbench |
| Studio intelligent development | Each completed build or optimization is now automatically saved as an immutable project version in the private Studio TOS bucket. Saved versions do not depend on the original Sandbox and can be viewed, downloaded, deployed, restored to a new session, or deleted after the session expires. The project version library groups versions by project and displays creation time, validation status, and artifact info for each version. Optimization builds expose before/after changes viewable in the source browser. | Studio agent workbench |
| Studio intelligent development | Any two saved versions of the same project can be compared in the project version library, showing file-level differences in a side-by-side diff view. Version comparison does not produce additional stored artifacts. | Studio agent workbench |
| Studio runtime environments | Environment image builds are accelerated: all system packages are now installed in a single apt-get transaction using the provider-local APT mirror (Volcengine uses mirrors.volces.com, others use mirror.sg.gs), reducing redundant network requests. Playwright and Chromium system dependencies are pre-installed alongside other system packages, no longer installed separately via playwright install --with-deps. | Studio agent workbench |
| Studio build logs | The build log panel now supports Bash syntax highlighting and auto-scrolls to the bottom by default; scrolling up pauses auto-follow, and scrolling back to the bottom resumes it. The log refresh interval is reduced from 5 seconds to 3 seconds. | Studio agent workbench |
| Studio project generation | The default veadk-python version in generated agent projects’ requirements.txt is updated from 1.1.5 to 1.1.6. | Studio agent workbench |
| Studio deployment | The --studio-update-bucket default for veadk studio deploy is now determined by the cloud provider: veadk-studio for Volcengine and veadk-studio-byteplus for BytePlus; previously it was always veadk-studio. | Studio agent workbench |
| Studio remote agents | Remote agents (A2A sub-agents) now support the BytePlus cloud provider: when BytePlus is selected, the agent center default region changes to ap-southeast-1, the default OpenAPI endpoint changes to https://agentkit.ap-southeast-1.byteplusapi.com/, and credentials are resolved from BYTEPLUS_ACCESS_KEY, BYTEPLUS_SECRET_KEY, and the optional BYTEPLUS_SESSION_TOKEN; Volcengine mode is unaffected. | Studio agent workbench |
| Studio remote agents | When updating a deployed agent, Studio now correctly restores A2A remote sub-agent registry configuration (REGISTRY_SPACE_ID, REGISTRY_TOP_K, REGISTRY_REGION, REGISTRY_ENDPOINT) from the runtime environment variables and preserves the remote agent type; previously these values could be lost or stale after an update. | Studio agent workbench |
1.1.6
VeADK 1.1.6 was released on August 25, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Studio deployment | When a build has been submitted but its final status cannot be confirmed, Studio marks the stage as “Build status pending,” prompting you to check the result in CodePipeline and disabling the retry button to prevent duplicate deployments; previously this situation was displayed as “Deploy failed.” | Studio agent workbench |
| Studio deployment | Deployment phase progression is now monotonically non-regressive; build log events no longer regress an already-deploying task back to the build phase. When a build-image failure occurs, Studio now retries syncing the final CodePipeline build log and marks it as failed, increasing the chance of locating the real failure cause at the end of the log; build log size limits are also increased. | Studio agent workbench |
| Harness Sidecar | In managed Sidecar mode, MCP tool calls now route through an in-process loopback proxy that normalizes session headers returned by the Runtime Gateway, avoiding MCP session initialization failures caused by calling the public gateway endpoint from within an active request. The managed Sidecar runtime command is now always set explicitly, not only when the compression provider is used. | Harness |
| Cloud provider | The --provider option on veadk studio, veadk frontend, veadk studio deploy, veadk studio update, and veadk deploy now defaults to the AGENTKIT_CLOUD_PROVIDER then CLOUD_PROVIDER environment variable, falling back to volcengine when neither is set; previously --provider hardcoded volcengine as the default. veadk deploy adds --provider, --region, --byteplus-access-key, --byteplus-secret-key, --byteplus-session-token, and --volcengine-session-token options for BytePlus deployment support. | Studio agent workbench · VeADK Frontend |
| Studio tracing | The trace panel now distinguishes five states: loading, collecting, not enabled, forbidden, and load failed. The collecting state retries automatically up to two times and provides a manual retry button; the forbidden state prompts contacting an administrator to grant APMPlus read permission; the load-failed state provides a reload button. Trace queries first locate the target trace by the POST /run_sse entry span and fall back to a broad scan of the session time window, selecting the closest trace when no match is found. | Studio agent workbench |
| Studio runtime | Streaming conversation error handling is improved: SSE parsing now handles incomplete final frames and reports raw data excerpts; empty responses or responses without model output produce explicit errors instead of failing silently; network-layer exceptions are formatted before display, and aborted requests retain received content. | Studio agent workbench |
| Studio security | When Studio runs with OAuth or gateway authentication, local ADK session reads, creates, updates, deletes, and agent run requests are bound to the signed-in identity: users can access only their own sessions, unauthenticated requests return 401, and non-admin cross-user access returns 403. Even when no role lists are configured (legacy “all users are admins” mode), cross-user session access still requires an explicit administrator-list entry; administrator access to other users’ sessions is recorded in an audit log. | Studio agent workbench |
| Studio security | Media upload, retrieval, and deletion endpoints now verify the requesting user owns the media. A2A Spaces and VikingDB knowledge-base list endpoints now require agent-management permission. Gateway-wide CORS is disabled by default during deployment, avoiding unnecessary cross-origin exposure. | Studio agent workbench |
| APMPlus telemetry | The APMPlus exporter supports BytePlus routing: the default OTLP endpoint is now derived dynamically from the cloud provider and region (format http://apmplus-{region}.volces.com:4317), and token-acquisition requests route to the provider OpenAPI host (open.volcengineapi.com for Volcengine, open.byteplusapi.com for BytePlus). | APMPlus |
| Studio telemetry | Cloud account ID resolution failures no longer interrupt deployment or update; the sanitized resolution error is recorded as account_id_resolution_error in the telemetry context. veadk studio deploy and veadk studio update now fall back to inferring the account ID from the TOS bucket name when direct resolution fails. Agent deployment failure events now include a sanitized, length-limited error_message field; during the build phase it is taken from the build log text, falling back to the deployment API error summary when no build log is available. | Studio agent workbench |
| Studio migration | A model selector is added to the migration composer next to the archive upload button, letting you choose the model the Dev Sandbox Codex uses for migration analysis and conversion. The model list comes from available Ark models activated under the current account, defaulting to the model returned by migration capabilities. The selected model’s configuration is injected into the migration session environment by the Studio server without sending credentials to the browser. The model cannot be changed after the task is created. | Studio agent workbench |
| Studio Skills | When viewing a skill’s files or downloading its ZIP, skills using the legacy SkillSpace interface type now load their complete file package and SKILL.md correctly; previously these skills failed to load because the version interface type did not match. When downloading and extracting a skill package, macOS metadata files such as __MACOSX directories and .DS_Store are ignored, the storage object is downloaded from the skill space’s region, and failures return a structured retryable error. | Studio agent workbench |
| Studio in-app update | In-app updates now perform an OTA permission pre-check before any mutation begins: the Function role is checked in read-only mode for all IAM permissions required to complete the update. When permissions are missing, the update is blocked; the dialog lists the missing items and provides an IAM console link for authorization. The administrator can retry the update after completing authorization. The pre-check does not modify IAM policies. | Studio agent workbench |
| Studio deployment | When the IAM permission pre-check in veadk studio deploy detects missing permissions, the command now prompts for confirmation instead of stopping immediately; the default is to decline (stopping the deployment), and confirming allows the deployment to proceed with the missing permissions. The --precheck-only mode still exits immediately without a confirmation prompt. | Studio agent workbench |
| Built-in tools | Adds invoke_skill and poll_skill built-in tools: invoke_skill creates a skill task non-blockingly via the A2A protocol and returns the initial task object, while poll_skill fetches a task status snapshot by task ID. Together they enable non-blocking skill task execution, complementing the blocking poll behavior of execute_skills. | Skill tasks · Code sandbox |
| Studio project generation | Generated requirements.txt now pins exact dependency versions for reproducible image builds; enabling the Feishu channel also pins lark-channel-sdk and lark-oapi versions. | Studio agent workbench |
1.1.5
VeADK 1.1.5 was released on August 23, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| AgentKit integration | create_agentkit_app adds enable_studio_tools and enable_studio_routes parameters: the former mounts the generic Runtime host for Studio BFF dynamic tools (StudioExternalToolset), the latter mounts the generic Runtime host for Studio BFF dynamic HTTP routes. Tool executors and route handlers always remain in the Studio BFF; the Runtime receives tool catalogs and route dispatches through a reverse channel. | Deploy to AgentKit |
| AgentKit integration | The session-scoped capability overlay endpoints (/harness/capabilities/tools, /harness/apps/{app_name}/users/{user_id}/sessions/{session_id}/capabilities, and /harness/run_sse) are removed and replaced by the Studio BFF dynamic tools mechanism. Runtimes without the dynamic-route opt-in keep their native Skill catalog handlers; opted-in Runtimes serve the three read-only Skill catalog routes (/harness/skills/findskill, /harness/skills/spaces, /harness/skills/spaces/{space_id}/skills) through the Studio BFF reverse route channel. | Deploy to AgentKit |
| Studio BFF | Studio can expose local or intranet-only tools to a compatible Runtime through a reverse channel without exposing a BFF public address. A compatible Runtime’s agent information rail adds an “Add Studio tools to this conversation” entry; new chats start with every Studio tool disabled, and the browser sends the selected tool ID list on each run. | Deploy to AgentKit |
| Built-in tools | image_edit, image_generate, and video_generate now resolve model credentials at tool execution time rather than at module import. Importing the tool module no longer initializes a client or requires credentials to be present. The resolution priority of each tool’s dedicated API key environment variables (MODEL_EDIT_API_KEY, MODEL_IMAGE_API_KEY, MODEL_VIDEO_API_KEY) is unchanged. | Image editing · Image generation · Video generation |
| Dependencies | Adds core dependency jsonschema>=4.23,<5 for validating Studio BFF dynamic-tool arguments. | Installation |
| Studio UI | The sidebar navigation is redesigned to align with the Figma design, unifying navigation item icons and layout; the “Library” page is renamed to “Resource library”. | Studio agent workbench |
| Studio website integration | Adds website integration (Beta): open the Website integration card on the Automation page, select a deployed Runtime, and enter a website domain to generate a dedicated Token and embed snippet. Pasting the <script> tag before </body> renders a floating chat window in the bottom-right corner. Visitors create one-hour sessions via the Studio embed endpoint and stream messages without accessing any credentials or direct Runtime addresses. Runtimes using custom JWT authentication are not supported. Integration records are persisted in TOS when persistent storage is configured, otherwise kept in process memory. | Studio agent workbench |
| Studio scheduled tasks | Studio adds a Scheduled tasks workspace (Beta): create and manage scheduled tasks from the “Scheduled tasks” sidebar entry, running a fixed text prompt against a deployed Runtime Agent on a recurring schedule. Supports one-time, daily, weekly, and five-field Cron expressions with IANA time zones. Task definitions, run locks, execution history, and results are stored in a Studio-private TOS bucket. | Studio agent workbench |
| Studio deployment | veadk studio deploy now additionally creates or updates two stateless VeFaaS functions with corresponding minute-trigger timers for scheduled-task dispatch; veadk studio update and in-app updates synchronize the dispatcher functions and timers. IAM permission precheck adds vefaas:ListFunctions, vefaas:GetFunction, vefaas:ListTriggers, vefaas:CreateTimer, and vefaas:UpdateTimer. | Studio agent workbench |
| Studio deployment | veadk studio deploy adds the --allow-dangerous-login flag: when enabled, it turns on local password, passwordless, sign-up, recovery, and unconfirmed-user login flows on the Studio-managed VeIdentity user pool; it takes effect only when --user-pool-id is not specified and does not modify custom user pools. | Studio agent workbench |
| Skill sandbox | When execute_skills calls the skills sandbox, it now reads the inbound identity credential from the credential service (credential key inbound_auth) and forwards it to the sandbox in the inbound_auth request header, so the sandbox workflow runs under the original user identity; when the current request carries no inbound credential, the header is omitted. | Code sandbox · Inbound authentication |
| Dependencies | Caps the Python version requirement below 3.14 (>=3.10,<3.14); Python 3.14 and later are not supported. | Installation |
| VeADK Web | veadk web now sanitizes the ADK dev server’s agent build-graph serialization: model fields are rendered as “provider/model-name” strings, runtime client objects no longer appear in the output, and the entire agent tree including nested sub-agents serializes correctly. | VeADK Web |
| Studio creation | When editing a system prompt in custom creation, content with Markdown syntax the editor cannot parse now falls back to plain-text mode for continued editing and saving instead of only showing a parse error. | Studio agent workbench |
| Studio deployment | When running veadk studio deploy (including --from-source) or veadk studio update and in-app updates on Windows, the run.sh in the deployment package is now written with LF line endings, preventing cloud function startup failures caused by CRLF line endings. | Studio agent workbench |
1.1.4
VeADK 1.1.4 was released on August 20, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Studio GitHub delivery | Adds the ability to deliver agents through GitHub: in the custom-creation deployment settings, choose “GitHub code sync” to push the generated source to the target branch (the Runtime is still published from the deploy button), or “Attach continuous delivery” to write an AgentKit Runtime GitHub Actions workflow to the target branch so subsequent pushes automatically build and publish to the bound Runtime; deployment adds an “Attach GitHub continuous delivery” phase with a live attach log. | Studio agent workbench |
| Studio version management | A “Versions” tab is added to the detail page of a Runtime bound to GitHub continuous delivery, listing the target-branch commit history, workflow runs, and publish status, with rollback support: when continuous delivery is attached, a rollback PR is merged automatically and publishing is triggered; with code sync only, a rollback PR is created for manual merging. | Studio agent workbench |
| CLI | Adds the veadk github-cicd-pipeline command, which pushes an AgentProject JSON exported by Studio to a target GitHub branch, corresponding to the code-sync mode. | Studio agent workbench |
| Dependencies | Adds the github-cicd optional dependency group (PyNaCl), used by Studio to encrypt GitHub Actions Secrets when attaching continuous delivery. | Installation |
| Dependencies | Relaxes the a2a-sdk version constraint to >=0.3.7,<1.0.0, allowing installation of newer A2A protocol SDK versions. | Installation |
1.1.3
VeADK 1.1.3 was released on August 20, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Studio deployment | When a build has been submitted but its final status cannot be confirmed, Studio marks the stage as “Build status pending confirmation,” prompting you to check the result later in Code Pipeline and disabling the retry button to prevent duplicate deployments; previously this situation was displayed as “Deploy failed.” | Studio agent workbench |
| Studio creation | When MCP-resilience governance is selected, MCP_URLS and MCP_API_KEY are now injected automatically (read-only) from the HTTP MCP tools configured earlier in the Add MCP Tool step, instead of requiring manual entry. At least one HTTP MCP tool with a valid service URL and Bearer Token is required; multiple HTTP MCP tools must share the same credential. MCP tools using stdio transport are not supported for MCP-resilience governance. | Studio agent workbench |
| Cloud provider | The --provider option on veadk studio, veadk frontend, veadk studio deploy, and veadk studio update now defaults to the AGENTKIT_CLOUD_PROVIDER then CLOUD_PROVIDER environment variable, falling back to volcengine when neither is set; previously --provider hardcoded volcengine as the default. | Studio · VeADK Frontend |
| Studio tracing | The trace panel now distinguishes five states: loading, collecting, not enabled, forbidden, and load failed. The collecting state retries automatically up to two times and provides a manual retry button; the forbidden state prompts contacting an administrator to grant APMPlus read permission; the load-failed state provides a reload button. Trace queries first locate the target trace by the POST /run_sse entry span and fall back to a broad scan of the session time window, selecting the closest trace when no match is found. | Studio agent workbench |
| Studio project generation | Generated requirements.txt now pins exact versions (veadk-python==1.1.5, agentkit-sdk-python==0.8.4, google-adk==2.1.0, starlette==0.52.1) for reproducible image builds; enabling the Feishu channel also pins lark-channel-sdk and lark-oapi versions. | Studio agent workbench |
| Local trace export | The Studio local debug trace exporter no longer indexes only call_llm spans; it now indexes all spans. Session ID attributes now include gen_ai.session.id and session.id, improving trace completeness within a session. | In-memory exporter |
| Studio security | When Studio runs with OAuth or gateway authentication, local ADK session reads, creates, updates, deletes, and agent run requests are bound to the signed-in identity: users can access only their own sessions, unauthenticated requests return 401, and non-admin cross-user access returns 403. Even when no role lists are configured (legacy “all users are admins” mode), cross-user session access still requires an explicit administrator-list entry; administrator access to other users’ sessions is recorded in an audit log. | Studio agent workbench |
| Studio deployment | When a build-image failure occurs, Studio now retries syncing the final CodePipeline build log and marks it as failed, increasing the chance of locating the real failure cause at the end of the log; build log size limits are also increased. | Studio agent workbench |
| Studio deployment | Deployment phase progression is now monotonically non-regressing; build log events no longer regress an already-deploying task back to the build phase. | Studio agent workbench |
| Studio telemetry | Cloud account ID resolution failures no longer interrupt deployment or update; the sanitized resolution error is recorded as account_id_resolution_error in the telemetry context. veadk studio deploy and veadk studio update now fall back to inferring the account ID from the TOS bucket name when direct resolution fails. | Studio agent workbench |
| Studio telemetry | Agent deployment failure events now include a sanitized, length-limited error_message field; during the build phase it is taken from the build log text, falling back to the deployment API error summary when no build log is available. | Studio agent workbench |
| Studio migration | A model selector is added to the migration composer next to the archive upload button, letting you choose the model the Dev Sandbox Codex uses for migration analysis and conversion. The model list comes from available Ark models activated under the current account, defaulting to the model returned by migration capabilities. The selected model’s configuration is injected into the migration session environment by the Studio server without sending credentials to the browser. The model cannot be changed after the task is created. | Studio agent workbench |
| Studio Skills | When viewing a skill’s files or downloading its ZIP, skills using the legacy SkillSpace interface type now load their complete file package and SKILL.md correctly; previously these skills failed to load because the version interface type did not match. When downloading and extracting a skill package, macOS metadata files such as __MACOSX directories and .DS_Store are ignored, the storage object is downloaded from the skill space’s region, and failures return a structured retryable error. | Studio agent workbench |
| Studio in-app update | In-app updates now perform an OTA permission pre-check before any mutation begins: the Function role is checked in read-only mode for all IAM permissions required to complete the update. When permissions are missing, the update is blocked; the dialog lists the missing items and provides an IAM console link for authorization. The administrator can retry the update after completing authorization. The pre-check does not modify IAM policies. | Studio agent workbench |
| Studio deployment | When the IAM permission pre-check in veadk studio deploy detects missing permissions, the command now prompts for confirmation instead of stopping immediately; the default is to decline (stopping the deployment), and confirming allows the deployment to proceed with the missing permissions. The --precheck-only mode still exits immediately without a confirmation prompt. | Studio agent workbench |
| AgentKit integration | create_agentkit_app adds enable_studio_tools and enable_studio_routes parameters: the former mounts the generic Runtime host for Studio BFF dynamic tools (StudioExternalToolset), the latter mounts the generic Runtime host for Studio BFF dynamic HTTP routes. Tool executors and route handlers always remain in the Studio BFF; the Runtime receives tool catalogs and route dispatches through a reverse channel. | Deploy to AgentKit |
| AgentKit integration | The session-scoped capability overlay endpoints (/harness/capabilities/tools, /harness/apps/{app_name}/users/{user_id}/sessions/{session_id}/capabilities, and /harness/run_sse) are removed and replaced by the Studio BFF dynamic tools mechanism. Runtimes without the dynamic-route opt-in keep their native Skill catalog handlers; opted-in Runtimes serve the three read-only Skill catalog routes (/harness/skills/findskill, /harness/skills/spaces, /harness/skills/spaces/{space_id}/skills) through the Studio BFF reverse route channel. | Deploy to AgentKit |
| Studio BFF | Studio can expose local or intranet-only tools to a compatible Runtime through a reverse channel without exposing a BFF public address. A compatible Runtime’s agent information rail adds an “Add Studio tools to this conversation” entry; new chats start with every Studio tool disabled, and the browser sends the selected tool ID list on each run. | Deploy to AgentKit |
| Built-in tools | image_edit, image_generate, and video_generate now resolve model credentials at tool execution time rather than at module import. Importing the tool module no longer initializes a client or requires credentials to be present. The resolution priority of each tool’s dedicated API key environment variables (MODEL_EDIT_API_KEY, MODEL_IMAGE_API_KEY, MODEL_VIDEO_API_KEY) is unchanged. | Image editing · Image generation · Video generation |
| Dependencies | Adds core dependency jsonschema>=4.23,<5 for validating Studio BFF dynamic-tool arguments. | Installation |
| Studio UI | The sidebar navigation is redesigned to align with the Figma design, unifying navigation item icons and layout; the “Library” page is renamed to “Resource library”. | Studio agent workbench |
| Studio website integration | Adds website integration (Beta): open the Website integration card on the Automation page, select a deployed Runtime, and enter a website domain to generate a dedicated Token and embed snippet. Pasting the <script> tag before </body> renders a floating chat window in the bottom-right corner. Visitors create one-hour sessions via the Studio embed endpoint and stream messages without accessing any credentials or direct Runtime addresses. Runtimes using custom JWT authentication are not supported. Integration records are persisted in TOS when persistent storage is configured, otherwise kept in process memory. | Studio agent workbench |
| Harness extension | HarnessExtension adds a managed Sidecar mode: enable via HarnessExtension.from_env() or the sidecar parameter to run all enhancement behavior in a separate managed runtime without loading plugins into the application process. New configuration classes HarnessSidecarConfig, ModelProxyConfig, and MCPGatewayConfig with corresponding environment variables are added. The in-process plugin mode remains available; the two modes are mutually exclusive. | Harness |
| Studio creation | Custom creation adds an Optimization step between Debug and Environment to enable Harness Sidecar optimizations for the agent. Choose optimization scenarios and components such as context governance, answer verification and repair, context and result compression, Goal-task control, or MCP-resilience governance; enhancement behavior runs in a managed runtime and the application process does not load the related plugins. This capability supports Volcengine accounts only. | Studio agent workbench |
| Studio navigation | Removed the Add Agent entry from the sidebar; agent creation is now accessed from the Create agent button on the Agents page. | Studio agent workbench |
| Studio navigation | The sidebar adds AgentKit console and documentation shortcuts that link to the AgentKit console and docs for the current cloud provider. | Studio agent workbench |
| Studio workspace | When selecting an agent in the workspace, Studio now prepares the session list, agent information, capabilities, and automatic evaluation statuses before changing the visible selection, eliminating intermediate loading states during the switch. | Studio agent workbench |
| Studio deployment IAM | When the VeFaaS service role ServerlessApplicationRole already exists, veadk studio deploy now reconciles missing custom and system policies for both Volcengine and BytePlus; previously this sync only applied to BytePlus. | Studio agent workbench |
| Studio memory | When the VikingDB Memory long-term memory backend is selected in custom creation, a new memory collection picker lists VikingDB memory collections visible to the current account via server-side credentials. Selecting an existing collection uses its name as the collection index and automatically fills the project, region, and memory-type environment variables (not shown on the creation page). If none is selected, the collection name is auto-generated from the agent name, and the collection is created at runtime if it does not exist. | Studio agent workbench · Use VikingDB storage |
| Region configuration | In Volcengine mode, components such as TOS, TOS Vector, TOS Context, VikingDB knowledge base and memory, VeIdentity, AgentKit Tools, and the sandbox now fall back to the REGION environment variable when the region is not explicitly set, before using each component’s default region (typically cn-beijing); BytePlus mode does not read REGION and is unchanged. | Code sandbox · VikingDB storage · TOS Vector storage · TOS Context storage · VikingDB memory · Studio workbench |
| Studio migration | During analysis and migration of an existing project, the “Codex activity” panel now renders execution progress in a structured form: analysis and migration plans show per-item completion status; command execution, file updates, external tool calls, web searches, and sub-task coordination each display their input, output, and exit code or error details, with error details shown on execution failure. All activity content is redacted server-side before reaching the browser. | Studio agent workbench |
| Studio sandbox | When creating sandbox sessions, display names whose UTF-8 encoding exceeds the session metadata byte limit no longer cause creation to fail; Studio truncates the name at a character boundary and appends an ellipsis. | Studio agent workbench |
| Studio system info | The System info page adds Codex Sandbox model environment repair: it detects whether the Tool environment variables for Codex Sandbox (SANDBOX_CHAT_CODEX) and its snapshot variant (SANDBOX_CHAT_CODEX_SNAPSHOT) are missing MODEL_AGENT_API_KEY or MODEL_AGENT_BASE_URL; when a value is missing and the Tool has both CODEX_API_KEY and CODEX_BASE_URL, an administrator can click the update button next to the Tool ID to have the Studio server backfill the missing variables. Keys are never sent to the browser. | Studio workspace |
| Studio system info | The sandbox information list on the System info page now includes DeepSeek Harness Sandbox (SANDBOX_CHAT_CODEX), which shares the same AgentKit CodeEnv Tool as Codex Sandbox and therefore shows the same Tool ID. Sandbox Tools are now listed in a fixed order. | Studio workspace |
| Studio navigation | The System info, agent detail, and sandbox agent detail pages now open over the current page, preserving the originating page. A back button in the top-left corner returns you to the page you were on before opening them; previously, opening these pages left the current view. | Studio workspace |
| Studio Skills | Creating a skill space now supports selecting a region: for Volcengine the options are cn-beijing and cn-shanghai (default cn-beijing), and for BytePlus ap-southeast-1; skill space cards also display their region, with spaces that have no explicit region showing the current cloud provider’s default region. | Studio workspace |
| Studio update | When editing a deployed agent, the agent name and model configuration loaded from the Runtime now reflect the actual deployed state: model names no longer include provider prefixes, and model sources (Ark or custom) are classified correctly against the ModelArk catalog. | Studio agent workbench |
| Studio update | When editing a deployed agent, Studio now rebuilds the editable draft exclusively from the Runtime’s currently deployed configuration instead of merging in locally saved drafts. When the Runtime’s agent configuration cannot be read due to a network or server error, the update entry is temporarily disabled with a retry notice. | Studio agent workbench |
| Studio video creation | The video task dialog now distinguishes whether the task is queued or the model is generating during the generation stage and shows the elapsed time. You can close the dialog while a task is generating and it continues running in the background. On failure the dialog displays the error details returned by the server (with keys and signatures automatically redacted); you can retry from the failed stage. | Studio agent workbench |
| Studio chat | Mermaid and ECharts code blocks in assistant replies now render as interactive diagrams with a toggle between preview and source. During streaming the source is shown first and the diagram renders after generation completes; aliases such as echart are also accepted. | Studio agent workbench |
| Studio agent creation | The maximum length of a generated agent instruction (system prompt) is raised from 20,000 to 40,000 characters. | Studio agent workbench |
| Studio knowledge | When importing a web page, Studio now shows a rendered preview of the extracted Markdown before saving. Only an explicit confirmation stores the content; cancelling or a preview failure leaves the knowledge base unchanged. Web documents are named automatically from the page title, falling back to the hostname. When the primary extractor yields no content, a fallback parser attempts to extract visible body text; pages that require JavaScript rendering and have no visible content report that they cannot be imported. Imported web documents show their original Markdown source when previewed in the knowledge base. | Studio agent workbench |
| Studio sandbox | When an administrator opens the sandbox session list, restorable snapshots for the listed agent kind are now resumed automatically (concurrently in the background, up to 3 at a time). The list then shows the ready sessions directly instead of requiring a manual wake. | Studio agent workbench |
| Studio agent creation | Custom creation adds an Environment step between Debug and Publish: select official CLI tools (Lark CLI, GitHub CLI, Pandoc) to bake into the cloud Runtime image, or customize the build Dockerfile via advanced configuration; choosing no tools and no custom Dockerfile keeps the default image build. The generated Dockerfile uses a provider-specific base image, installs tools with per-architecture SHA-256 verification, and never contains credentials. | Studio agent workbench |
| Studio in-app update | In-app updates no longer modify the Function’s IAM role policy; to update IAM permissions, use the veadk studio update command. When the Function role lacks the vefaas:GetApplicationRevisionLog permission, the log panel is replaced with a permission notice linking to the corresponding provider’s IAM console so an administrator can grant access; the update continues without interruption. | Studio agent workbench |
| Studio creation | Adds the Intelligent development creation flow: on Add Agent, select “Intelligent development” and describe a goal in natural language; Codex in the sandbox then determines the intent, builds the project, debugs it, and performs a temporary cloud validation to produce a deployable source artifact. After the build completes, a delivery card appears in the conversation where you can view the source, download a ZIP, or deploy directly to an AgentKit Runtime; deployment materializes the source server-side from the validated delivery artifact and only creates a new Runtime. Intelligent-development sessions are retained for up to 8 hours, appear in the sidebar history, and support resumption and deletion. This feature requires a configured Dev Sandbox Tool (SANDBOX_DEV). | Studio agent workbench |
| Studio intelligent development | When resuming or reopening an intelligent-development session, the conversation history shows only user messages and assistant responses; internal intent-gate and task-scheduling steps are no longer displayed. | Studio agent workbench |
| Studio intelligent development | During builds, progress messages appear as a separate progress indicator in the conversation, distinct from the assistant’s text output; the indicator disappears automatically when the current turn completes. | Studio agent workbench |
| Studio intelligent development | Delivery summaries now follow a structured Markdown format: a one-sentence outcome summary first, followed by sections for Completed, Validation, and Remaining issues. | Studio agent workbench |
| Studio security | Tool calls, thinking content, and progress messages from intelligent development are redacted server-side before being sent to the browser; task credentials and private paths are removed. | Studio agent workbench |
| Studio skill upload | macOS metadata files inside __MACOSX directories are now ignored when uploading skill ZIP archives; these files are not written to the skill space. | Studio agent workbench |
| Remote skills proxy | Adds remote skills proxy: declaratively expose skills hosted in the AgentKit Skills Sandbox as individual tools via a JSON manifest, with per-skill description, input schema, and timeout. The framework forwards each call to the remote sandbox via execute_skills; skill code runs only remotely. | Remote skills proxy |
| Built-in tools | Adds invoke_skill and poll_skill built-in tools: invoke_skill creates a skill task non-blockingly via the A2A protocol and returns the initial task object, while poll_skill fetches a task status snapshot by task ID. Together they enable non-blocking skill task execution, complementing the blocking poll behavior of execute_skills. | Skill tasks · Code sandbox |
| Model | When using Volcengine Ark models, multiple text or multimodal parts within a single message are now correctly aggregated into one input item. Previously, these parts could be split into separate input items or the final part could be omitted. | Model |
| Tracing | During streaming model calls, request events are now emitted only once on the first chunk instead of being duplicated on every chunk; None attribute values are now consistently removed from all span events. | Observability overview |
| Studio sign-in | The browser session lifetime is no longer fixed at 1 hour: when the VeIdentity user-pool client has a configured refresh-token lifetime, Studio extends the session accordingly and refreshes the access token transparently on expiry, preventing mid-session sign-outs. | Studio agent workbench |
1.1.2
VeADK 1.1.2 was released on August 17, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Studio UI | The browser tab title now changes dynamically with the active view: the new-conversation home shows only the system name; an open conversation shows the conversation name; other pages such as Automation, System info, Create agent, Library, and Search show the form “System name - Page name”. Previously the title was always the system name. | Studio agent workbench |
| Studio built-in agent | Built-in Codex sessions now recover automatically after an idle timeout or transport disconnection: on the next message or request, Studio rebuilds the connection and resumes the current Thread, preserving conversation history, workspace lock state, and context usage without requiring a manual new session. | Studio agent workbench |
| Studio deployment | When creating or locating VeIdentity user pools and clients and registering the SSO callback, veadk studio deploy uses only the deployer-provided credentials and no longer falls back to VeFaaS IAM credentials in the runtime environment, preventing unintended temporary credentials from being used during deployment. | Studio agent workbench |
| Studio local-to-cloud handoff | Adds local-to-cloud handoff: on the Codex tab of “Manage agents”, click “Handoff” to open a guided dialog and, in order, copy the plugin-install prompt and the handoff prompt (containing the Studio URL and a one-time pairing code with a 20-minute default validity). The local Codex plugin then migrates the project code, Git metadata, and visible conversation history (including images attached to user messages) into a temporary cloud Codex Sandbox Session and continues the task in the cloud. Progress is shown across “Waiting for local request”, “Creating cloud Session”, “Restoring project”, and “Sending continuation task”; you can open the cloud session after completion. History is limited to 100 messages, 20,000 characters per message, and 100,000 characters total; up to 10 images (PNG/JPEG/GIF/WebP), 4 MB each and 8 MB total. The entry is visible only to admin and developer. | Studio agent workbench |
| Studio Sandbox | Adds the STUDIO_EXPOSE_SANDBOX_ENDPOINT environment variable (disabled by default). When enabled, the Codex session editor shows a “Copy Sandbox Endpoint” button next to the composer that copies the current Sandbox public endpoint to the clipboard; it is configured via an environment variable for both local and deployed Studio. | Studio agent workbench |
| Studio update | veadk studio update now registers the /oauth2/callback callback of the current Studio public URL on the bound VeIdentity user-pool client with skip-consent during update, so SSO login remains usable after the update; on failure it prints a warning and instructs manual addition. Querying existing deployments and submitting the code-bundle update now automatically retries transient server errors such as rate limiting and network jitter; if it still fails after retrying, the terminal notes that the cloud release may still be in progress and you can rerun the same command shortly after. | Studio agent workbench |
| Studio library | A “Library” page is added to the sidebar, consolidating Skills, Knowledge, and Artifacts into three tabs. The previous “Skills” entry is merged into the Skills tab of the library. | Studio agent workbench |
| Studio knowledge | A Knowledge tab is added to the library page: create and manage user-owned AgentKit knowledge bases. Names must start with a letter and contain only letters, digits, and underscores (1–48 characters); descriptions are up to 80 characters. Upload images (PNG/JPG/JPEG) and documents (PDF/PPTX/DOCX/XLSX/TXT, up to 200 MB per file), or import public web pages: Studio fetches pages server-side, extracts the main content as Markdown with SSRF protection, redirect and size limits. Files are relayed through private TOS storage before being imported into the AgentKit knowledge base. | Studio agent workbench |
| Studio artifacts | An Artifacts tab is added to the library page: browse documents, images, and videos generated during conversations, grouped by session source, with type filtering and search. Image and video artifacts are persisted to Studio persistent storage and remain available after refreshing or switching sessions; persisted artifacts support editing the name, description, and tags, as well as downloading and deletion. Only images and videos are synced, and source URL validation (HTTPS addresses from trusted generation services only) prevents writing content from untrusted sources. | Studio agent workbench |
| Studio deployment | veadk studio deploy now generates or reuses the VEADK_STUDIO_KNOWLEDGE_SIGNING_KEY environment variable to identify knowledge base ownership; veadk studio update checks and reconciles this variable. The IAM permission pre-check adds apig:UpdateRoute to enable the HTTP methods required by Studio APIs. | Studio agent workbench |
| Studio creation | Adds existing-project migration: on Add Agent, select “Migrate an existing project” and upload an archive (up to 50 MB). Studio creates a user-owned Dev Sandbox Session (1-hour TTL) where Codex performs read-only framework, entry-point, and migration-boundary analysis. After the user confirms the framework, entry, and open questions, migration starts; Structured frameworks (LangChain, LangGraph, Google ADK, Strands, AgentCore) run ak migrate, while Dify and Any run ak migrate --execution in-place. After migration, you can preview, download, or deploy to AgentKit; deployment verifies the artifact server-side from the Session. | Studio agent workbench |
| Studio deployment | Code-package deployment now supports agentkit.yaml for the entry point: when the root contains an agentkit.yaml that declares common.entry_point, the declared file is used as the entry point; otherwise app.py at the root is used as before. | Studio agent workbench |
| Studio deployment | When creating a new Runtime, the Runtime name can be edited manually. Studio validates the name format (4–64 characters, letters, digits, underscores, and hyphens only) and checks for conflicts with existing Runtimes in the selected region before deployment; if the name is already in use, deployment prompts for a different name. | Studio agent workbench |
| Studio built-in agent | Adds the DeepSeek Harness built-in agent: select DeepSeek Harness from the built-in agent submenu in a new conversation to open the DeepSeek Harness workspace in an independent AgentKit CodeEnv Session. This agent shares the same CodeEnv Tool (SANDBOX_CHAT_CODEX) as the Codex agent; sessions are distinguished by an agent-kind identifier. | Studio agent workbench |
| Studio telemetry | Studio frontend telemetry adds an anonymous entry-visit metric: a single anonymous page entry is recorded on page load before the user signs in, and user identity is associated only after sign-in, distinguishing anonymous visits from authenticated visits. veadk studio deploy and veadk studio update automatically resolve the cloud account ID during deployment or update and write it to the runtime environment; it is delivered to the frontend via /web/ui-config for telemetry correlation without manual configuration. | Studio agent workbench |
| Studio in-app updates | In-app update deployment logs are now filtered on the server to remove curl progress bars, config JSON dumps, ANSI escape sequences, and duplicate lines, retaining only deployment-relevant content. When the deployment credentials lack VeFaaS log-query permission, the log panel is hidden automatically instead of showing an error, without interrupting the update. After the update completes, Studio automatically reloads the page to load the new version; if an update dialog was open before the reload, it is automatically restored when the page reopens. | Studio agent workbench |
| Studio system information | The TOS bucket address, sandbox Tool IDs, and user pool names on the system information page now provide links to the corresponding cloud console pages. The user pool display field changed from UID to ID. | Studio agent workbench |
| Studio deployment | The default value of VEIDENTITY_REGION changes from a fixed cn-beijing to the current cloud provider’s default region (cn-beijing for Volcengine, ap-southeast-1 for BytePlus). | Studio agent workbench |
| Studio update | veadk studio update now refreshes the managed policies of the default Studio IAM role to the latest version when the function uses the default role; custom roles are not modified. | Studio agent workbench |
| Studio built-in agent | When an error occurs during a conversation with the built-in Codex agent (app-server error or connection interruption), Studio now displays the complete error detail — including the JSON-RPC error code, message, data, and the underlying cause — instead of a truncated message. Error information is still credential-redacted. | Studio agent workbench |
| Studio creation | The “Create from scratch” entry no longer shows a mode-selection submenu; clicking it directly enters the custom creation flow. The intelligent, template, and workflow sub-options have been removed. | Studio agent workbench |
| Studio model selection | When configuring an LLM agent in custom creation, a model selector lets you browse the Ark models activated under the current account and choose a target model: the list is fetched by the Studio server, includes only LLM and VLM models that support agent calls, and shows the model name, display name, vendor, and activation status — deactivated models are excluded. The list is cached server-side with manual refresh support. | Studio agent workbench |
| Studio model credentials | When using Ark models, the Studio server selects an Ark API Key from the current account’s key list for debug runs and deployment: the default selection matches MODEL_AGENT_API_KEY_NAME, falling back to the first key if no match is found. You can manually select a specific Ark API Key in the deployment configuration area; the selected key’s raw value is resolved by the server and injected into the runtime environment without being sent to the browser. | Studio agent workbench |
| Studio custom models | When using a custom model endpoint, generated project code now includes CUSTOM_MODEL_<agent_name>_PROVIDER and CUSTOM_MODEL_<agent_name>_API_BASE environment variables for the model provider and model API base URL respectively; the model API Key is still read from the CUSTOM_MODEL_<agent_name>_API_KEY environment variable. | Studio agent workbench |
| Studio deployment | When creating a new Runtime, Studio auto-generates a Runtime name from the root agent name (composed of letters, digits, underscores, and hyphens, 4–64 characters), keeping agent and Runtime naming consistent; the deployment result returns both the agent name and the Runtime name. | Studio agent workbench |
| Studio branding | The maximum length for --site-title increases from 6 to 16 characters, affecting the veadk studio, veadk studio deploy, and veadk studio update commands. | Studio agent workbench |
| Studio model credentials | Studio binds model credentials to trusted endpoints: when the model API base URL is blank or uses the official Ark endpoint for the current cloud, Studio automatically provides the Ark API Key for debug runs and deployment; when a custom model endpoint is used, Studio provides no credential, debug runs are not supported with custom endpoints, and the publish page requires an API Key for each agent using a custom endpoint (used only for that publish). Generated project code reads the credential from the CUSTOM_MODEL_<agent_name>_API_KEY environment variable. | Studio workspace |
| Studio evaluation | In conversations with a deployed agent, you can select a text fragment within an assistant reply and add an annotation to save that turn as a Bad Case evaluation sample: the selected fragment and the annotation note are combined into the case comment, and annotated cases display a score and the annotation reason in the evaluation set. This capability is available only when connected to a deployed Volcengine Runtime after the reply has finished generating; BytePlus deployments and local debug sessions are not supported. | Studio workspace |
| Studio deployment | veadk studio deploy and veadk studio update harden sandbox Tool provisioning: transient errors (rate limits, network failures, temporary server errors) are automatically retried; concurrent Tool creations are staggered to avoid rate limits; each creation carries an idempotency token to prevent duplicates. Provisioning failure messages now include the Tool ID and cloud service error code, status code, and request ID. | Studio agent workbench |
| Studio deployment | veadk studio deploy automatically runs a read-only IAM permission pre-check before creating cloud resources: it reads the caller’s attached IAM policies, evaluates each required IAM Action, and prints a permission table. When permissions are missing, the deployment stops before creating resources and prints the IAM configuration URL for the corresponding cloud provider. A new --precheck-only option runs only the pre-check without creating any resources. | Studio agent workbench |
| Frontend chat | A “Share as image” button is added next to each assistant reply to export all inputs and outputs up to that turn as a single PNG image. The image is generated locally in the browser, includes every message from the start of the session through the current reply with an export note appended at the bottom, and supports downloading as PNG or copying to the clipboard. This applies to both the veadk frontend and veadk studio conversation pages. | Studio agent workbench · VeADK Frontend |
| Studio in-app updates | The “What’s new” notice on the new conversation page now displays the actual release notes bundled with the current build instead of fixed content. Release notes in the update dialog are rendered as individual bullet points per entry. | Studio agent workbench |
| Studio sandbox | Administrators can view and restore wakeable agent snapshots in the sandbox session list: restorable snapshots left by ended built-in agent sessions appear in the list with a “Wakeable” status. You can wake a snapshot to restore a ready session or delete it; the detail page shows the snapshot status, reason, Snapshot ID, and source Session ID. This capability is available only to the admin role and requires the sandbox snapshot Tool to be configured. | Studio agent workbench |
| Studio telemetry | Studio frontend product-behavior telemetry migrates from the APMPlus Web SDK to TEA: it is automatically enabled when running veadk studio (including local startup and veadk studio deploy instances) and no longer requires configuration. veadk studio deploy removes the --apmplus-aid, --apmplus-token, --apmplus-domain, and --apmplus-env options and the corresponding VEADK_STUDIO_APMPLUS_AID, VEADK_STUDIO_APMPLUS_TOKEN, VEADK_STUDIO_APMPLUS_DOMAIN, and VEADK_STUDIO_APMPLUS_ENV environment variables. Telemetry collects only usage dimensions; failure events retain only the error kind and error code. VeADK runtime APMPlus tracing is unaffected. | Studio agent workbench |
| Studio usage statistics | A “Usage statistics” tab is added to deployed agents: one invocation is recorded after each Studio run_sse stream finishes successfully without an SSE error; failed, cancelled, direct API Server, and direct A2A calls are not counted. The tab shows total invocations, unique signed-in users, per-user invocation counts, and each user’s latest successful invocation. Usage is stored in the Studio private TOS bucket (VEADK_STUDIO_TOS_BUCKET and VEADK_STUDIO_TOS_REGION), provisioned and injected automatically for cloud deployments; each invocation is an immutable object so concurrent Studio instances do not overwrite a shared counter. Only administrators and developers who can access the Runtime may read the user list; a storage failure never interrupts the Agent response, and the tab instead reports that usage statistics are temporarily unavailable. | Studio agent workbench |
| Frontend chat | While an agent is replying, the composer’s send button becomes a stop button; clicking it cancels only the active response, preserves any content already received, and immediately enables the next turn in the same session. This applies to both the veadk frontend and veadk studio conversation pages, including sandbox conversations. | VeADK Frontend |
| Frontend chat | A context usage indicator is added beside the composer’s send button: it shows the current model’s context window occupancy. Hovering or focusing it expands a 100-cell usage map that breaks down the context into system and tool overhead (estimated), input and history, output and reasoning, and remaining capacity. System and tool usage is an estimate because the model’s usage metadata does not report it separately. The context window size is determined by the cloud provider and model name. This applies to both the veadk frontend and veadk studio agent conversation pages. | VeADK Frontend |
| Code sandbox | execute_skills removes the invocation_mode parameter and the AGENTKIT_SKILL_INVOCATION_MODE environment variable; skill workflows now run exclusively through the A2A protocol. | Code sandbox |
| Code sandbox | execute_skills no longer supports the env_vars parameter; passing a non-None value raises an error. | Code sandbox |
| Code sandbox | run_code timeout default changes from 30 to 300 seconds with range validation (1–300 seconds); hard_timeout also gains 1–300 second validation. | Code sandbox |
| Feishu channel | FeishuChannelExtension adds graceful shutdown: start() begins a background reconnect loop on the running event loop, shutdown() closes the WebSocket and waits for already-received messages to finish before returning, drain() waits for in-flight message tasks to complete, and is_draining reports the shutdown state. New TOOL_FEISHU_CHANNEL_RECONNECT_INTERVAL (default 3 seconds) and TOOL_FEISHU_CHANNEL_DRAIN_TIMEOUT (default 300 seconds) environment variables. Intended for ASGI application startup and shutdown hooks. | Feishu |
| Feishu channel | Fixes streamed replies being corrupted or truncated when a delta chunk’s leading character matched the accumulated tail, because the dedup heuristic dropped overlapping text. Streamed output is now concatenated directly from delta chunks. | Feishu |
| Knowledge base | Under byteplus, the VikingDB knowledge base backend no longer hardcodes the TOS region and endpoint to ap-southeast-1; instead, it automatically aligns with the knowledge base region (e.g., cn-hongkong → tos-cn-hongkong.bytepluses.com). Explicit tos_config or DATABASE_TOS_REGION / DATABASE_TOS_ENDPOINT values are still respected. | Use VikingDB storage |
1.1.1
VeADK 1.1.1 was released on August 12, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Studio models | The default BytePlus sandbox Tool model changes from seed-2-0-lite-260228 to dola-seed-2-1-turbo-260628. | Studio agent workbench |
| Code sandbox | execute_skills adds a timeout parameter to control the maximum execution time, defaulting to 1800 seconds (30 minutes) with a valid range of 1–1800 seconds. | Code sandbox |
| Studio skill center | Skill upload and publish name-conflict checks are now scoped from the project level to the target skill space: a same-name skill is rejected only when the conflict is within the same skill space; the existence of a skill with the same name in a different skill space no longer blocks upload or publishing. | Studio agent workbench |
| Studio skill center | Skill publish storage bucket resolution adds a new fallback chain: when no dedicated publish bucket is configured, Studio first reuses the persistent storage bucket (VEADK_STUDIO_TOS_BUCKET and VEADK_STUDIO_TOS_REGION), then falls back to the bucket from the AgentKit global configuration, and finally auto-generates one. When falling back to the Studio persistent storage bucket, the bucket region is validated against the skill publish region; publishing fails if they do not match. | Studio agent workbench |
| Studio in-app updates | In-app updates now support BytePlus deployments: the release bundle is no longer tied to a cloud provider — Volcengine and BytePlus share the same release source. During the update, the cloud-provider entry point is selected automatically based on the CLOUD_PROVIDER (or AGENTKIT_CLOUD_PROVIDER) environment variable in the deployment, and BytePlus deployments also have BYTEPLUS_REGION written during the update. During the update, Studio checks the current VeFaaS Function for missing cloud resources and provisions them automatically (TOS persistent storage and sandbox snapshot Tools), so that older Studio versions gain the new capabilities after upgrading. The VeFaaS Function console link in the update status is provider-specific. | Studio agent workbench |
| Studio knowledge base | Custom agent creation adds the OpenViking knowledge base backend; service URL, API key, knowledge owner ID, resource URI, and resource index can be configured on the creation page and are written to the generated project’s environment variables. | Studio agent workbench · Store knowledge in OpenViking |
| Studio tracing | The cloud-Runtime trace query on the conversation page now selects the APMPlus OpenAPI endpoint by cloud provider: open.volcengineapi.com for Volcengine and open.byteplusapi.com for BytePlus, preventing failed trace queries under BytePlus mode caused by using the wrong endpoint. | Studio agent workbench |
| Skills | When skills are loaded through Harness, CLI-generated agent code, or the AgentKit session capability service, VeADK automatically configures a local code executor for SkillToolset, so skill scripts run without additional configuration. | Skills |
| Studio evaluation | Optimization snapshots from automatic evaluation are now persisted to Studio persistent storage: when VEADK_STUDIO_TOS_BUCKET and VEADK_STUDIO_TOS_REGION are configured (the deploy command auto-creates the bucket), snapshots are stored in TOS, survive process restarts, and are shared across instances. When persistent storage is not configured, snapshots remain in process memory and are lost on restart. | Studio agent workbench |
| Studio deployment | When veadk studio deploy automatically provisions an Identity user pool, a TOS bucket, or sandbox Tools, the success output additionally prints a summary of configured cloud resources: each sandbox Tool type and ID, the private TOS storage address, user pool ID, client ID, and a link to the Identity console for the corresponding cloud provider. It also notes that password sign-in is disabled by default and that an SSO identity provider must be configured before inviting users. | Studio agent workbench |
| Studio deployment | --user-pool-id and --allowed-client-id are now optional for veadk studio deploy. When omitted, the deploy command creates or reuses a named VeIdentity user pool (veadk-studio-{vefaas-app-name}) and web client (veadk-studio-{vefaas-app-name}-web) in the region selected by --region, and prints the Identity region, user pool ID, user pool domain, and client ID on completion. Passing both options still uses existing resources with the original cross-region lookup behavior. | Studio agent workbench |
| Studio deployment | Deploying a new Runtime to AgentKit supports configuring the cloud build resources: TOS bucket, Container Registry (CR), and CodePipeline. Each resource group supports auto-create (default), specify names, or select existing; when selecting existing, Studio loads the available resource list for the current account via the server. The selected resources are recorded as Runtime tags and preserved when updating an existing Runtime. | Studio agent workbench |
| Studio Skill Center | A “Skills” page is added to the sidebar for skill space management: browse skill spaces by region and name, with create, edit, and delete support. Administrators see all spaces; non-admins see only their own. Within each space, skills can be uploaded as ZIP archives (up to 20 MiB), browsed as a file tree, downloaded as ZIP, and deleted. | Studio agent workbench |
| Studio skill generation | The Skill Center adds Dev Sandbox skill generation: creates independent development sandbox sessions via a DevEnv Tool to generate ADK-format skills from natural-language descriptions. Supports up to 3 parallel candidate groups with model and style selection, automatic format-validation repair (up to 2 attempts), iterative refinement, and direct publishing to a skill space; also supports optimizing existing skills with overwrite publishing. Available only to developer and admin roles and requires an administrator-configured DevEnv Tool. | Studio agent workbench |
| Studio chat modes | The “Create Skill” mode is removed from the new-conversation mode selector; skill creation is now handled exclusively through the Skill Center using the Dev Sandbox. veadk frontend, veadk studio, veadk studio deploy, and veadk studio update remove the --sandbox-skill-creator-tool-id (--skill-creator-tool-id) option and the SANDBOX_SKILL_CREATOR environment variable. | Studio agent workbench |
| Studio system information | The “System info” entry in the account menu changes from a dialog to a full page. In addition to the Studio version, it now shows sandbox information (configured Codex, OpenClaw, Hermes, and Dev Sandbox Tool IDs) and user pools (VeIdentity user pools associated with the current Studio, showing name, UID, domain, and region). The page is available only to users with agent-management access, and resource identifiers are read-only. | Studio agent workbench |
| Studio login | When using BytePlus as the cloud provider with VeIdentity login, the default login-button label is now “BytePlus Identity”; the volcengine default remains “火山引擎 Identity”. Setting --oauth2-provider-label (or OAUTH2_PROVIDER_LABEL) always takes precedence. | Studio agent workbench |
| Studio deployment | While a deployment is in progress, the workspace detail page focuses on the deployment progress: it keeps the agent heading and a scrollable deployment panel visible and hides the other detail tabs and content; the normal detail tabs return after the deployment ends. Custom creation, code-package deployment, and updating a deployed agent all follow this behavior. | Studio agent workbench |
| Studio automation | The “Configure Coding Agents” card is now enabled only when Studio is accessed at http://127.0.0.1; when accessed via any other hostname (including localhost or a deployed VeFaaS public URL), the card appears disabled with a “仅本地部署可用” tooltip. | Studio agent workbench |
| Studio deployment | After a successful deployment, Studio retries probing the Runtime endpoint for up to 60 seconds before timing out, reducing the frequency of the “Deployed, not yet connected” state. | Studio agent workbench |
| Studio deployment | When a deployment fails or is cancelled, the progress card now provides a “Return to edit” button that takes you back to the draft to adjust the configuration and start a new deployment. | Studio agent workbench |
| Studio skill generation | The skill generation workbench improves its layout: a “Basic info” section is added, the Goal field is marked as required; the “Generation configuration” section is renamed to “Generation plan” (or “Optimization plan” when optimizing), and the model and style within each plan are marked as required. | Studio agent workbench |
| Studio Skill Center | The skill creation entry in the Skill Center is relabeled from “Dev Sandbox create” to “Auto-create”, and the empty-state hint is updated accordingly. | Studio agent workbench |
| Studio sandbox | --sandbox-dev-tool-id and the SANDBOX_DEV environment variable are no longer restricted to Volcengine deployments; BytePlus deployments and updates now support the Dev Sandbox: deployments auto-create the DevEnv Tool, and updates detect and repair missing Tools. | Studio agent workbench |
| Studio video creation | The new-conversation page adds a “Video creation” workspace mode that generates videos from a text prompt and optional reference assets. It supports text-to-video, reference-to-video, video editing, video extension, and first/last-frame task modes with configurable aspect ratio, resolution, and duration. Generation runs in two stages — prompt enhancement and video generation — and the result can be previewed and downloaded. Volcengine uses the doubao-seedance-2-5-260628 generation model and doubao-seed-2-1-pro-260628 enhancer model; BytePlus uses dreamina-seedance-2-5-260628 and dola-seed-2-1-turbo-260628. | Studio agent workbench |
| Studio skill customization | The new-conversation page adds a “Skill customization” workspace mode that provides a quick entry point for skill generation and optimization, reusing the Skill Center’s Dev Sandbox skill generation. The mode is available only to developer and admin roles and appears only after an administrator configures a usable Dev Sandbox. | Studio agent workbench |
| Studio persistent storage | Video creation and other capabilities add Studio persistent storage: veadk studio deploy automatically creates or reuses a private TOS bucket named veadk-studio-<account ID>; local startup is configured via the VEADK_STUDIO_TOS_BUCKET and VEADK_STUDIO_TOS_REGION environment variables. Reference asset upload and result storage depend on this storage. | Studio agent workbench |
| Studio system info | System information page access is restricted from “agent-management access” to the admin role only, and a new “Storage” section shows the TOS address used by Studio persistent storage. | Studio agent workbench |
1.1.0
VeADK 1.1.0 was released on August 7, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Studio cloud provider | veadk studio, veadk frontend, veadk studio deploy, and veadk studio update add a --provider option for selecting volcengine (default) or byteplus; selecting BytePlus uses BYTEPLUS_ACCESS_KEY, BYTEPLUS_SECRET_KEY, and the optional BYTEPLUS_SESSION_TOKEN for credentials, with runtime listings defaulting to the region in BYTEPLUS_REGION or ap-southeast-1. veadk studio deploy and veadk studio update add --byteplus-access-key, --byteplus-secret-key, and --byteplus-session-token options. | Studio agent workbench · VeADK Frontend |
| Studio deployment | veadk studio deploy adds --vefaas-application-template-id to override the built-in VeFaaS Application Center template ID, and --keep-failed-deploy to retain created resources on failure for troubleshooting; --region now includes ap-southeast-1. veadk studio update adds --volcengine-session-token, and --region likewise includes ap-southeast-1. | Studio agent workbench |
| Studio branding | The default system name for veadk studio and veadk frontend changes from VeADK Studio to AgentKit Studio, and the default logo is updated to the AgentKit brand logo. The new defaults apply when --site-title, --site-logo, or their environment variables are not set. | Studio agent workbench |
| Studio deployment | Updating an existing Runtime now preserves its current network configuration (network mode, VPC, subnets, and shared internet access) instead of losing it. | Studio agent workbench |
| Studio drafts | Unpublished agent drafts from custom creation are saved in the current browser and isolated by signed-in user. Drafts show draft and deploying badges in the management list and can be edited or deleted. Drafts convert MCP auth tokens to environment-variable references; token values are preserved in deployment environment variables, YAML exports, and browser drafts. | Studio agent workbench |
| Studio MCP auth | MCP tool auth tokens are converted to environment-variable references: generated source retains only the ${ENV_NAME} reference and reads it via os.environ, with the token value written to deployment environment variables; updating a deployed Runtime reloads existing values, and entering a new Token overrides the previous value. | Studio agent workbench |
| Studio Runtime env | Updating a deployed Runtime preserves existing environment-variable values; when a Runtime target is selected for a debug test run, the Runtime environment variables are injected into the test process. | Studio agent workbench |
| Studio MCP endpoint | MCP tool HTTP endpoints are no longer auto-normalized; Studio preserves the entered address as-is and shows a warning when it does not end with /mcp. | Studio agent workbench |
| Studio issue feedback | Each assistant reply on the conversation page gains an “Issue feedback” entry that reports a problem for a single turn by selecting an issue type (slow execution, crash, inaccurate result, tool call failure, or other) and adding a description; the submission includes the turn’s input, output, tool-call records, and trace information and is redacted for credentials. A “Issue feedback” entry (Beta) is added to the sidebar footer for reporting general Studio issues by affected module. | Studio agent workbench |
| Studio tracing | The call-trace observation panel next to assistant replies on the conversation page supports viewing traces for connected cloud Runtimes: the Studio server queries APMPlus for the session trace using its own Volcengine credentials and the browser never touches them. Runtimes deployed through Studio have APMPlus tracing enabled by default; opening the panel for a Runtime without tracing enabled prompts you to enable it in the console first. | Studio agent workbench |
| Studio in-app updates | Studio now reads new releases from the centrally maintained veadk-studio TOS source in cn-beijing, regardless of the deployment region. The --studio-update-region option and VEADK_STUDIO_UPDATE_REGION environment variable are removed from veadk studio deploy; --studio-update-bucket and --studio-update-prefix remain available to override the release source. | Studio agent workbench |
| Studio automation | The Automation page in the sidebar adds a “Configure Coding Agents” local integration: it detects locally installed Trae, Claude Code, and Codex clients and globally installs the bundled VeADK development and AgentKit platform-operation Skills into each client’s skills directory. The browser can only choose fixed identifiers and never accepts arbitrary commands or Skill content. | Studio agent workbench |
| Studio telemetry | veadk studio deploy adds --apmplus-aid, --apmplus-token, --apmplus-domain, and --apmplus-env options (and matching environment variables) to configure APMPlus frontend telemetry. Telemetry is enabled only when both aid and token are provided, is disabled by default, and reporting failures do not affect Studio usage. It collects only usage dimensions and never conversation content, prompts, code, or secrets. | Studio agent workbench |
| Studio telemetry | Expands frontend telemetry coverage: in addition to instance loading, sign-in, agent deployment, and sandbox creation, telemetry now records agent connection, message sending, debug test runs, and source code download outcomes, along with creation mode and whether AI-assisted generation was used; error summaries in failure events are automatically redacted for secrets, tokens, and passwords and truncated before reporting. | Studio agent workbench |
| Studio creation | The Add Agent menu adds an “Existing-project migration” entry for migrating LangChain, Dify, and other existing projects to AgentKit Runtime; it is currently marked as coming soon and disabled. | Studio agent workbench |
| Studio automation | The sidebar “Automation” page adds three GitHub automation integrations: template project import, AgentKit Runtime continuous delivery, and automated PR review. These create branches, files, and Pull Requests directly via the browser using the GitHub API to add continuous delivery or automated review workflows to repositories. The GitHub Token is used only for the current request and never persisted. | Studio agent workbench |
| Studio automation | The sidebar “Automation” page adds a Feishu bot automation (Beta): after providing Feishu app credentials, Studio generates a basic agent and deploys it directly to an AgentKit Runtime with the Feishu message long-connection enabled. The App Secret is used only for the current deployment and never written to generated source or browser storage. | Studio agent workbench |
| Studio memory | Custom agent creation adds the OpenViking long-term memory backend; service URL, API key, memory owner ID, and memory policy can be configured on the creation page and are written to the generated project’s environment variables. | Studio agent workbench · Store memory in OpenViking |
| Long-term memory | When memory_policy is not configured, OpenViking long-term memory no longer applies a VeADK built-in default policy; instead no policy is sent and the OpenViking service applies its official default. | Store memory in OpenViking |
| Studio evaluation | Deploying an agent adds an “Auto-create evaluation sets” toggle (enabled by default) that automatically creates Good Case and Bad Case evaluation sets after deployment succeeds. On failure, a warning is shown in the deployment result without affecting the deployed Runtime. | Studio agent workbench |
| Studio evaluation | After a conversation session ends, Studio automatically evaluates each turn by calling a model that scores task completion, factual reliability, and other dimensions (0–1), saving the result to the Good Case or Bad Case evaluation set. Auto-evaluated cases are marked as “auto” source with a score and reason, and can be filtered and deleted alongside manual feedback cases. | Studio agent workbench |
| Studio evaluation | The agent workspace adds an “Optimization” tab that automatically generates optimization suggestions grouped by priority and module, based on accumulated evaluation cases. The evaluation model can be overridden with the VEADK_STUDIO_EVALUATION_MODEL environment variable. | Studio agent workbench |
| Studio deployment | New Runtime creation supports choosing an access authentication mode: API Key by default, or a VeIdentity user pool. The Studio server loads the user pools visible to the current account and marks the pool used for the current login; selecting it lets Studio forward the login JWT, while selecting another pool requires callers to use a JWT issued by that pool. Updating an existing Runtime keeps its current authentication. | Studio agent workbench |
| Studio sandbox | veadk studio deploy and veadk studio update add --sandbox-dev-tool-id (and the SANDBOX_DEV environment variable) to specify or auto-create the AgentKit DevEnv Tool for the Dev Sandbox; supported only for Volcengine deployments and raises an error when used with BytePlus. | Studio agent workbench |
| Studio sandbox | Sandbox Tool model, endpoint, and candidate regions are now provider-specific: Volcengine uses the doubao-seed-2-1-pro-260628 model with https://ark.cn-beijing.volces.com/api/v3 and candidate regions cn-beijing and cn-shanghai; BytePlus uses the seed-2-0-lite-260228 model with https://ark.ap-southeast.bytepluses.com/api/v3 and candidate region ap-southeast-1. BytePlus deployments no longer skip sandbox Tool auto-provisioning and now auto-configure Tools per provider. | Studio agent workbench |
| Studio Codex session | Image attachments uploaded in Codex agent conversations now render previews inline in the conversation and open in a shared photo viewer when clicked, instead of producing duplicate previews. | Studio agent workbench |
| Studio creation | When BytePlus is the cloud provider, web_search and parallel_web_search are not shown in the built-in tool list for custom creation or smart generation; Volcengine mode is unaffected. | Studio agent workbench |
| Web search | web_search and parallel_web_search switch to the BytePlus SearchInfinity API when CLOUD_PROVIDER is set to byteplus, using BYTEPLUS_WEB_SEARCH_API_KEY for credentials and the optional BYTEPLUS_WEB_SEARCH_URL to override the search endpoint. | Web search |
| Long-term memory | The VikingDB memory backend BytePlus region is now fixed at cn-hongkong and is no longer affected by the DATABASE_VIKING_REGION environment variable or an explicitly passed value; credential resolution now checks AGENTKIT_CLOUD_PROVIDER then CLOUD_PROVIDER, reading BYTEPLUS_ACCESS_KEY, BYTEPLUS_SECRET_KEY, and BYTEPLUS_SESSION_TOKEN when set to byteplus. | Use VikingDB storage |
| Knowledge base | The VikingDB knowledge backend BytePlus region is now determined by a mapping rule: an unset or Chinese-mainland region (cn-beijing, cn-shanghai, cn-guangzhou) is automatically mapped to cn-hongkong, while other regions are used as-is; credential resolution now checks AGENTKIT_CLOUD_PROVIDER then CLOUD_PROVIDER, reading BYTEPLUS_ACCESS_KEY, BYTEPLUS_SECRET_KEY, and BYTEPLUS_SESSION_TOKEN when set to byteplus; a new resource_id constructor parameter and DATABASE_VIKING_RESOURCE_ID environment variable are added for request routing in multi-resource scenarios. | Use VikingDB storage |
| Code sandbox | When run_code runs code or Shell commands, the AgentKit request timeout now extends with timeout and hard_timeout, preventing long-running tasks from being interrupted by a fixed read timeout. | Code sandbox |
| Code sandbox | execute_skills adds an invocation_mode parameter and the AGENTKIT_SKILL_INVOCATION_MODE environment variable to switch the skill sandbox backend between execute (default), run_sse, a2a, and python_agent modes; the prefer_stream parameter has been removed. | Code sandbox |
| Models | When CLOUD_PROVIDER is set to byteplus, the default inference model changes from dola-seed-2-1-turbo-260628 to seed-2-0-lite-260228. | Models |
| Models | When CLOUD_PROVIDER is set to byteplus, the default embedding model changes from doubao-embedding-vision-250615 to skylark-embedding-vision-250615, with the API base switched to BytePlus Ark. | Models |
1.0.10
VeADK 1.0.10 was released on August 4, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Studio agent directory | The agent directory now switches by agent-type tabs and supports filtering by name. It loads the signed-in user’s runtimes across all regions and automatically loads the next page while scrolling; agent cards are simplified to name and creation time, the connected agent is pinned to the top, and a reload option is available when loading fails. | Studio agent workbench |
| Studio deployment | Build logs are streamed in real time in the deployment progress card during the build stage, with expand, collapse, and copy support; logs are redacted and length-bounded on the server, and build failures append the failure detail. | Studio agent workbench |
| Studio sandbox sessions | When creating a Session or looking up the Tool for built-in agents or Skill creation, Studio first uses the region set by AGENTKIT_SANDBOX_REGION (default cn-beijing); if that region reports the resource as not found, it automatically falls back to the other supported region (Beijing ↔ Shanghai). Other errors do not trigger fallback. | Studio agent workbench |
| Studio deployment | When deploying to AgentKit, the root agent description is automatically normalized to a Runtime-compliant single-line description (at most 255 bytes, with line breaks, control characters, and unsafe symbols removed); the full description is kept in the project. If the normalized description is rejected by Runtime, creation is retried without the description. | Studio agent workbench |
| Studio deployment & debugging | When a build or deployment stage fails, the workspace shows the complete error message returned by the service, expanded by default and copyable. Build errors now render in the same expandable error panel as deployment errors. | Studio agent workbench |
| Studio role-based access | The Manage Agents view and the agent selector now uniformly limit Runtime visibility by the signed-in account role. Administrators see all Runtimes; developers and regular users see only their own. When an administrator browses all Runtimes, the ones they created are marked “Created by me.” | Studio agent workbench |
| Studio test-run MCP endpoints | Test runs now normalize HTTP MCP tool endpoints on generated agents: a URL not ending in /mcp is appended automatically, tool discovery is validated over Streamable HTTP, and a failure returns an error prompting the user to confirm the URL and token; the original URL saved on the canvas is not modified. | Studio agent workbench |
| Studio integration methods | The agent detail page adds an “Integration methods” tab that probes the Runtime for exposed API Server and A2A protocol endpoints, shows the authentication type and API Key (masked by default, revealed on demand), and provides a Python request example for each protocol. | Studio agent workbench |
| Studio drafts | Unpublished agent drafts from custom creation are saved in the current browser and isolated by signed-in user. Drafts show draft and deploying badges in the management list and can be edited or deleted. MCP auth tokens and deployment environment values are not persisted and must be re-entered after a reload. | Studio agent workbench |
| Studio deployment | veadk studio deploy supports STS temporary credentials via the --volcengine-session-token option; the session token is resolved from the option, the VOLCENGINE_SESSION_TOKEN / VOLC_SESSIONTOKEN environment variables, and the session_token field of the [default] profile in ~/.volc/credentials. | Studio agent workbench |
| Knowledge base | The OpenViking knowledge base default resource URI now uses viking://user/<openviking_user_id>/resources/<index>/; a new openviking_user_id parameter and DATABASE_OPENVIKING_USER_ID environment variable isolate resources per application, and KnowledgeBase gains a close() method to release the backend client. | Store knowledge in OpenViking |
| Long-term memory | OpenViking long-term memory adds openviking_user_id as the owner/context (distinct from Runner.user_id, the peer ID), plus a memory_policy parameter and DATABASE_OPENVIKING_MEMORY_POLICY environment variable to override the default memory extraction policy. | Store memory in OpenViking |
| Studio Codex session | The built-in Codex agent conversation adds dedicated session controls: slash commands, model switching, Skill invocation, workspace selection, Codex permissions, action approvals, terminal and browser tools, plus per-turn token usage and conversation history restore. | Studio agent workbench |
| Studio deployment | Creating a new Runtime supports configuring minimum and maximum instance counts; defaults to 1–1 with a prompt to switch to persistent storage when using in-memory short-term memory. A non-default range adds an “Update instance configuration” stage to the deployment progress. | Studio agent workbench |
| Studio sessions | Session listings skip sessions that no longer exist instead of failing the entire list. | Studio agent workbench |
| Studio sandbox sessions | The “Created by” field in sandbox session listings now shows the creator display name (OAuth email or local username) instead of an internal user identifier; it falls back to the internal identifier when no display name is available. | Studio agent workbench |
| Studio error guidance | run_sse failures now distinguish between a missing session and an incompatible Runtime version, offering respective guidance to switch to persistent storage or check the Runtime version. | Studio agent workbench |
| Studio cloud provider | veadk studio and veadk frontend add a --provider option for selecting volcengine (default) or byteplus; selecting BytePlus uses BYTEPLUS_ACCESS_KEY, BYTEPLUS_SECRET_KEY, and the optional BYTEPLUS_SESSION_TOKEN for credentials, with runtime listings defaulting to the region in BYTEPLUS_REGION or ap-southeast-1. | Studio agent workbench · VeADK Frontend |
| Studio smart generation | Generated drafts no longer configure memory, knowledge base, or tracing; these capabilities stay disabled with default backends and can be enabled manually on the canvas after generation. The web_scraper, text_to_speech, and vesearch built-in tools are removed from the selectable set. | Studio agent workbench |
| Studio smart generation | Smart generation now prefers an LLM agent as the root agent instead of always using a sequential orchestrator; an orchestrator is used as the root only when strict workflow control is essential. | Studio agent workbench |
| Studio agent selection | In cloud mode Studio no longer auto-selects the first available agent; users must connect a Runtime before starting a new chat, and starting without a selection prompts them to choose one and opens the management page. | Studio agent workbench |
| Studio agent deletion | A confirmation dialog listing the items to be removed appears before deletion; deleted agents are temporarily hidden from the list, and if the active agent is deleted the selection is cleared and the management page opens. | Studio agent workbench |
| Studio message feedback | Feedback is associated with the Runtime’s actual app name and falls back to the alternate region when the primary region query fails; a “View evaluation cases” button next to the like/dislike controls previews the evaluation sample for the current message. | VeADK Frontend |
| AgentKit integration | The dynamic A2A run endpoint now creates a session automatically when it does not exist, instead of returning 404. | Deploy to AgentKit |
| AgentKit integration | create_agentkit_app adds an optional identity parameter; when supplied, AgentKit verifies and binds the inbound user identity before VeADK Agent or Tool code runs. The /ping health-check endpoint is excluded from identity binding. Using this parameter requires agentkit-sdk-python>=0.8.2. | Deploy to AgentKit |
| Studio new-chat experience | The new-chat mode selector is available to all users, the agent picker moves to the top navigation, temporary session is renamed to built-in agent with Codex selection, and empty inputs show starter prompts. | Studio agent workbench |
| Dev server | The --vite mode of veadk studio and veadk frontend allows http://localhost:5174 as a fallback to port 5173. | Studio agent workbench · VeADK Frontend |
| Studio code-package deployment | Adds an “Add and deploy from a code package” flow for uploading, inspecting, and editing a ZIP project with a root app.py before deployment to AgentKit. Archives are limited to 50 MB and 800 files and undergo path-safety checks. | Studio agent workbench |
| VeADK Frontend | When an SSO session expires during use, users can sign in again in a separate window while preserving edits, and the original action is retried automatically. | VeADK Frontend |
| Studio chat | Replies from a sub-agent are displayed in a dedicated Agent handoff card when the root agent delegates a task. | Studio agent workbench |
| Studio skills | SkillSpace browsing uses server-side Studio credentials, local imports perform lightweight safety validation, full cloud skill packages include scripts, references, and assets when available, and the fixed per-agent skill limit is removed. | Studio agent workbench |
| Codex runtime | Adds the codex optional dependency group and CodexRuntimeConfig; defaults use session-isolated workspaces, the workspace_write sandbox, disabled network access, and denied escalation, while tool, state, authentication, and token-usage events are emitted as standard ADK Events. | Runtime |
| Studio deployment | The VeFaaS Application now uses the selected deployment region together with the Function, API Gateway, and AgentKit resources. | Studio agent workbench |
| Studio agent workspace | Adds a canvas-based multi-agent workspace with Runtime versions and deployment states. Deployed agents can be edited and published as incremented versions on the same Runtime, and cancelling an update leaves the existing Runtime intact. | Studio agent workbench |
| Studio smart generation | Generates a validated recursive agent-configuration draft from a natural-language goal and lists resources the user must supply. Generation replaces the current canvas and consumes tokens. | Studio agent workbench |
| Studio Runtimes | Read-only readiness probes retry while a Runtime starts, private-Runtime failures provide VPC guidance, and Studio connects after deployment while preserving tasks for retry when the Runtime is temporarily unreachable. | Studio agent workbench |
| Studio debugging | Agent details and versions refresh after Runtime creation or update. Generated-agent test processes are limited to 3 per user, and processes left by page refreshes are reclaimed automatically. | Studio agent workbench |
| Studio test runs | A single temporary test run accepts up to 300 project files. | Studio agent workbench |
| Models | The minimum google-adk version required for the Responses API is now 1.34.0. | Models |
| APMPlus tracing | Reasoning content in model output is labeled with the reasoning type to distinguish it from regular text, making it easier to inspect the reasoning process separately in APMPlus. | APMPlus |
| APMPlus tracing | When OpentelemetryTracer initialization detects an existing global TracerProvider, it reuses that provider instead of overriding it and automatically removes APMPlusExporter; a new read-only property apmplus_managed_externally is available to query this state. | Observability overview · APMPlus |
1.0.9
VeADK 1.0.9 was released on July 26, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Long-term memory | Added the TOS ContextBucket backend for managed memory inference and retrieval with per-user_id isolation. | Store memory in TOS ContextBucket |
| Studio knowledge bases | Agent creation now defaults to VikingDB Knowledge, removes the local vector-store option, and can select an existing knowledge-base collection visible to the current account in the Beijing-region default project. | Studio agent workbench |
| Studio remote agents | Remote-agent configuration can select and refresh AgentKit agent centers by region. Remote agents remain available only as sub-agents. | Studio agent workbench |
| Studio message feedback | AgentKit Runtime answers can be rated with like/dislike controls and written idempotently to per-agent evaluation sets. A deterministic fallback is used when the standard set name is reserved but hidden. | VeADK Frontend |
| Studio release and self-update | veadk studio deploy uses the veadk-studio TOS bucket in the deployment region as its release channel by default. Administrators can update the frontend and backend in Studio, and the account menu shows the current system version. | Studio agent workbench |
| Session capability overlays | AgentKit applications can add or remove built-in tools and remote skills for one session without changing the deployed agent. | Deploy to AgentKit · Studio agent workbench |
| Studio agent information | The conversation view adds an agent information rail for the current agent’s description, model, tools, skills, and collaboration topology. | VeADK Frontend |
| Studio creation workbench | Custom creation adds code-execution configuration and resource-picker search, including AGENTKIT_TOOL_ID and AGENTKIT_TOOL_REGION. | Studio agent workbench · Code sandbox |
1.0.8
VeADK 1.0.8 was released on July 23, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Studio remote agents | Custom creation supports remote-agent child nodes configured with an AgentKit agent-center ID, recall count, region, and OpenAPI endpoint. Matching capabilities are discovered for each turn, and a remote agent cannot be the root agent. | Studio agent workbench |
| Studio Runtimes | Runtime connection failures distinguish access denied, Agent Server unreachable, and authentication failure, with corresponding troubleshooting guidance. | Studio agent workbench |
| Studio sessions | Preserves conversation history when sending follow-up messages. Temporary-session and Skill-creation provisioning failures display credential-safe diagnostics for Tool, region, or model-credential problems. | Studio agent workbench |
| Studio deployment credentials | veadk studio deploy resolves credentials from command options, VOLCENGINE_ACCESS_KEY / VOLCENGINE_SECRET_KEY, then the [default] profile in ~/.volc/credentials. | Studio agent workbench |
| Studio deployment resources | Shanghai deployments keep the Function, API Gateway, AgentKit CodeEnv Tools, and sessions in consistent regions. Temporary-session and Skill-creation model credentials are configured on their Tools, while the VeFaaS Function receives only Tool IDs. | Studio agent workbench |
1.0.7
VeADK 1.0.7 was released on July 23, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Code sandbox | run_code adds bash language support to run shell scripts in the AgentKit sandbox, with exec_dir, env, hard_timeout, and max_output_length parameters that control the working directory, environment variables, hard timeout, and maximum output length. | Code sandbox |
| Studio creation modes | Adds Skill creation across two independent AgentKit CodeEnv sessions; candidates can be compared, downloaded as a ZIP, or published to AgentKit, and the mode is available to developers and admins only. Also adds temporary conversations that are deleted on exit and are not written to normal Studio history. | Studio agent workbench |
| Studio smart search | Adds agent-aware smart search over conversation history, the mounted web-search tool, knowledge base, and long-term memory. Agent metadata advertises mounted sources, and Studio disables unavailable sources. | Studio agent workbench |
| Studio roles and access | Adds --admin and --developer to veadk studio, veadk frontend, and veadk studio deploy. The UI displays the signed-in user’s email, role badge, and OAuth profile picture. | Studio agent workbench |
| Studio update command | Adds veadk studio update --vefaas-app-name <name>, which rebuilds Studio from a local VeADK checkout while preserving the existing URL, SSO, IAM role, gateway, environment variables, title, and logo. When --region and --project are omitted, it searches Beijing and Shanghai across all visible projects. | Studio agent workbench |
| Studio deployment | veadk studio deploy automatically creates the two AgentKit CodeEnv Tools used by temporary chats and Skill creation; existing Tool IDs can be supplied with --sandbox-chat-codex-tool-id and --sandbox-skill-creator-tool-id. After deployment, client sign-in skips repeated OAuth consent. | Studio agent workbench |
| Feishu channel | FeishuChannelExtension can fetch thread history and quoted messages through the Feishu OpenAPI, using include_parent_message, include_thread_history, and thread_history_limit, and prepends the quoted or thread content to the inbound message. | Feishu channel |
| Studio workbench | Refines the custom-creation workbench: local Skills accept folders or ZIP files with automatic format detection; AgentKit Skill Spaces and their Skills can be browsed by region and project; the deployment page shows the agent topology and supports configuration export and source download. It also improves runtime management and responsive layout, new-chat startup, the agent runtime selector, video rendering, and tool-call status display. | Studio agent workbench |
| Dependencies | Relaxes the psycopg2-binary version constraint to >=2.9.10; requires the AgentKit SDK to provide default CORS configuration. | Installation |
1.0.6
VeADK 1.0.6 was released on July 20, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Studio branding | veadk studio and veadk frontend add --site-title (at most 6 characters) and --site-logo (local image or HTTP(S) URL, at most 5 MB; PNG, JPEG, GIF, WebP, AVIF, ICO supported) to set the system name and logo. The logo is used in the sidebar, login page, and browser favicon; the system name also becomes the browser page title. Omitting --site-title keeps the default VeADK Studio. The equivalent environment variables are VEADK_SITE_TITLE and VEADK_SITE_LOGO. Cloud deployment accepts the same options; remote images are downloaded during deployment and bundled into VeFaaS. | Studio agent workbench |
| Studio deployment | veadk studio deploy supports --region to select the deployment region (cn-beijing by default, cn-shanghai); VeFaaS, API Gateway, and other resources are created in the selected region. A new --project selects the VeFaaS function project and defaults to default. Deployment automatically locates the VeIdentity user pool and client across Beijing and Shanghai, emitting a warning and continuing when matched cross-region. | Studio agent workbench |
| Studio deployment IAM | veadk studio deploy checks ServerlessApplicationRole before deployment and creates the role with the vefaas_full_access custom policy and required system policies when it is missing. This check runs even when --iam-role is provided. | Studio agent workbench |
| Studio authoring and debugging | System prompts now support a WYSIWYG Markdown editor with heading and list shortcuts. Initialization, session, and conversation failures show credential-redacted error details and Runner logs that can be expanded and copied. Agent names are validated against Google ADK rules: they must start with an ASCII letter or underscore, contain only ASCII letters, digits, and underscores, cannot use the reserved name user, and must be unique within the Agent tree. | Studio agent workbench |
| AgentKit deployment | Feishu, knowledge-base, short-/long-term memory, and observability settings appear in their respective feature sections; their values are converted to runtime environment variables only during deployment. Selecting an observability exporter also enables the corresponding ENABLE_* flag. These values are not written to generated source or exported YAML; the deployment page mirrors them for review. Multi-instance deployments should use a database-backed short-term memory store; when run_sse returns 404, the UI suggests checking whether an in-memory or SQLite session landed on a different instance. When deploying from the bundled Web UI, cloud image build failures include a credential-safe build-log excerpt so dependency or Dockerfile errors can be diagnosed directly. | Deploy to AgentKit |
| Studio runtime management | Improved the runtime management view and responsive layout. | Studio agent workbench |
| Feishu channel | Toggling the Feishu channel on the deployment page regenerates the project so that app.py, the extensions dependency, and runtime environment variables stay aligned before deployment. | Studio agent workbench |
1.0.5
VeADK 1.0.5 was released on July 19, 2026. The following table lists its public user-facing changes. See the GitHub Release for the complete commit history.| Module | Change details | Link |
|---|---|---|
| Studio and Frontend | Studio now enables the same complete UI as Frontend and opens on the chat view by default. Added cloud Runtime selection, Skill Hub/local upload/AgentKit SkillSpace sources, multimodal conversations, and structured skill and sub-agent invocation. The custom creation flow was redesigned; intelligent, template, and workflow entries are currently marked as coming soon. Also improved deployment regions, environment variables, task status, retry behavior, and OAuth token forwarding. | VeADK Frontend · Studio agent workbench |
| Models | Changed the default inference model to doubao-seed-2-1-pro-260628; Responses API now supports fallback models and Ark context management. | Models |
| Runtime | Added piagent to Agent.runtime, including bridges for function tools, MCP tools, and skills; the package no longer vendors the PiAgent binary. | Runtime |
| Studio testing | Generated agent projects can run in a restricted temporary server-side test process. The process is retained for 1,800 seconds by default and can be adjusted with a command option. | Studio agent workbench |
| Studio deployment | When Studio is deployed with its default IAM role, the command adds the system policies needed to access model, logging, tracing, knowledge, memory, and identity resources. An explicitly supplied custom role is not modified. | Studio agent workbench |
| AgentKit integration | Studio-generated applications now use the public create_agentkit_app function to provide AgentKit endpoints, health checks, topology, the built-in Web UI, and short-term memory defaults. | Deploy to AgentKit |
| Feishu channel | Improved extraction of text, card, and merged-forward messages and added compatibility with the synchronous Channel SDK lifecycle. | Feishu channel |
1.0.4
VeADK 1.0.4 was released on July 14, 2026. The following table lists its public user-facing changes.| Module | Change details | Link |
|---|---|---|
| Studio | Added veadk studio, a focused workbench for agent creation and management. It supports intelligent, custom, and template creation; the workflow entry is marked as coming soon. AgentKit deployment progress is reported by stage. | Studio agent workbench |
| Agent management | Added an AgentKit runtime management view to Frontend and Studio. It lists workbench deployments for the current user, shows Runtime and primary-agent details, and can delete runtimes. | Studio agent workbench |
| VeFaaS deployment | Added veadk studio deploy to deploy Studio to VeFaaS with VeIdentity login and create or reuse a Serverless API Gateway and IAM role. | Studio deployment |
| VeADK Frontend | Added agent topology and transfer-path visualization. Project deployment now reports live build-image, deploy, and publish stages. | VeADK Frontend |
| Harness skills | Harness skills accepts space:<skill-space-id> to load an entire AgentKit skills-center space alongside Skill Hub names or slugs. | Skills |
| Frontend security | Removed the action that directly executed browser-submitted code; restricted the AgentKit proxy protocol, host, and credential requirements; and confined deployment and static-file paths. | VeADK Frontend |
| Logging | Migrated logging to Python’s standard logging package while retaining trace-ID correlation. Non-interactive output no longer contains color escapes, and streaming reasoning is no longer logged token by token. | Application logging |
| Storage configuration | Expanded Milvus and OpenViking environment and configuration examples. Version 1.0.4 continues to provide the Milvus knowledge, OpenViking knowledge, and OpenViking long-term memory backends introduced in 1.0.3. | Milvus · OpenViking knowledge · OpenViking memory |
1.0.3
VeADK 1.0.3 contains the following public user-facing changes.| Module | Change details | Link |
|---|---|---|
| Knowledge base | Added the milvus backend with Milvus service and Milvus Lite URIs, token or username/password authentication, database selection, initialization overwrite, timeout, and additional output fields. | Store knowledge in Milvus |
| Knowledge base | Added the openviking backend for importing files, directories, and text into OpenViking and retrieving and hydrating results by resource URI. | Store knowledge in OpenViking |
| Long-term memory | Added the openviking backend to store per-user entity, event, and preference memory while retaining user isolation across sessions. | Store memory in OpenViking |
| A2A | Calls to downstream agents in the AgentKit A2A Registry can propagate inbound X-Ve-TIP-Token and bearer JWT credentials. If a downstream call made with the inbound JWT returns 401, VeADK can fall back to M2M OAuth2 and retry once. | Inbound authentication |
| Dependencies | Consolidated duplicate dependency declarations, added the OpenViking SDK to the base dependencies, and added Milvus integrations to extensions. | Installation |
1.0.2
VeADK 1.0.2 contains the following public user-facing changes.| Module | Change details | Link |
|---|---|---|
| Models | Added MODEL_AGENT_API_KEY_NAME and Agent.model_api_key_name to resolve an Ark API key by name. An explicit key value still has higher precedence. | Model configuration |
| Short-term memory | Added PostgreSQL schema configuration to isolate session tables for separate deployments in one database. VeADK creates a missing schema and pins the connection’s search_path. | Store sessions in PostgreSQL |
| MCP | After an MCP Server session expires, the service restarts, or the connection drops, VeADK discards the stale session, reconnects, and retries tool discovery or execution once. | Custom MCP Server |
| Frontend | Added a tool OAuth authorization card to VeADK Frontend: it opens the identity provider, accepts the callback, submits the credential, and resumes the original tool call. Also refined the account entry, login page, session list, empty-response notice, and default agent selection. | VeADK Frontend |
| Network requests | VeSearch and web-fetch requests use a 30-second timeout so an unresponsive service does not block indefinitely. | Volcengine search · Web fetch |
| Security | Web fetch verifies TLS certificates, and content-safety debug logs do not record API-key values. | Web fetch · Content-safety guardrail |
1.0.1
VeADK 1.0.1 was released on July 7, 2026. It adds Harness, A2A registration, and ADK skill integration, with updates to the Codex runtime and VeADK Frontend.| Module | Change details | Link |
|---|---|---|
| Codex runtime | Ships sandbox, network, and review defaults that allow full host and network access without interactive approval. | Runtime safety |
| Harness | Adds the VeADK Harness extension to prepare context for each turn, compact large tool results, and verify final answers; Harness initialization also applies the agent description. | Harness plugins |
| A2A | Adds Harness A2A registration and corrects its registration behavior. | Remote-agent discovery |
| A2A | Adds OAuth authentication to A2A calls. | A2A authentication |
| Codex runtime | Adds configurable retries for transient backend errors and restores web search through the Responses shim. | Codex backend requests |
| Skills | Adds VeSkillRegistry for using SkillHub and Skill Space sources with Google ADK SkillToolset; local skills should migrate to ADK SkillToolset, while the legacy Agent(skills=..., skills_mode="local") entry point remains compatible but is deprecated. | Cloud skills |
| VeADK Frontend | Adds gateway authentication mode and a missing-Volcengine-credentials notice during agent creation. | Frontend authentication |
| Codex runtime | Passes agent skills through to the Codex runtime. | Codex skills and tools |
| Codex runtime | Executes an agent’s MCP and function tools through the Codex runtime. | Codex skills and tools |
| Examples | Adds a Codex-runtime example that combines a local skill with an MCP tool. | Codex skills and tools |
1.0.0
VeADK 1.0.0 was released on June 22, 2026. The table follows the public release notes; the published change from 0.5.40 is limited to the documentation entry-point wording.| Module | Change details | Link |
|---|---|---|
| Documentation | Aligned the Chinese quickstart card with the English card so it explicitly says users can build and run their first agent. | Quickstart |