Changelog

Today, we’re launching the official Lattice SDK skills. These teach coding agents how to create integrations using the latest best practices, so that you can get to a working integration as quickly as possible.

For installation instructions, more on how they work, and how we measure how well agents perform with these skills, see Lattice SDK skills.

The Lattice Schema Registry (LSR) is now available at https://schema-registry.developer.anduril.com.

The LSR enables you to publish, share, and use schema definitions with the Protobuf Interface Definition Language. Log in with your existing Lattice Developer single sign-on (SSO).

The Lattice Developer Console gives you a consolidated view of your data in Lattice. Use it to inspect and debug entities, tasks, and objects. The Developer Console is now the default app on Lattice Sandboxes at https://your_lattice_url.com/developer-console, but you still have access to the operator view at https://your_lattice_url.com/c2.

The Lattice Sandboxes developer portal now uses Okta to manage access. The new sign-in experience replaces the previous email, password, and authenticator-app MFA flow with a passkey-based login at https://login.developer.anduril.com.

The Lattice SDK now supports streaming task updates in real-time using the gRPC API:

• Added StreamTasks gRPC endpoint for establishing persistent connections to stream task events
• Implemented Go/gRPC example demonstrating how to connect and process task streams
• Updated documentation to include gRPC usage patterns alongside existing REST examples

The StreamTasks gRPC API provides the same configurable parameters as the REST version:

• heartbeatIntervalMs: Configures how frequently the server sends heartbeat events to verify connection health.
• excludePreexistingTasks: Controls whether to stream only new tasks created after the connection is established or include existing tasks.
• taskType: Allows filtering the stream by task type prefix, reducing bandwidth usage and focusing on relevant task updates.

As a part of this release, the Operate on tasks guide has been updated with a Go/gRPC code example. The example demonstrates how to establish a task stream connection, process heartbeat events, and handle incoming task events using the gRPC protocol.

The Lattice SDK now supports task cancellation through the CancelTask API available in both REST and gRPC. This API lets an operator request to cancel, giving you greater control over task lifecycle management.

The cancellation behavior depends on the task’s current state:

• Tasks not yet sent to an agent cancel immediately and transition to a terminal state.
• Tasks already sent to an agent receive a cancellation request that the agent can accept or reject based on the task’s execution state.

The Lattice SDK now supports two new APIs that use server-sent events (SSE) for real-time task monitoring in Lattice:

1. StreamTasks - For monitoring all tasks across your Lattice environment.
2. StreamAsAgent - For receiving tasks assigned to specific agents.

These new features provide instant updates on task creation, status changes, and completion without the need for polling, and replace the previous polling-based approach:

Lattice now supports machine-to-machine (M2M) authentication using the OAuth 2.0 client credentials flow. This gives you more control over permissions and improved security using short-lived tokens.

Today we have released new versions of the Lattice SDK in all four languages. This contains the following changes:

• ⚠️ Breaking change - This addresses an issue where the centerRayPose component on the Entity was incorrectly modelled. If you were using this component, you will need to update your code to reference the new fields.
• Dependency updates and other bug fixes

Today we have released new major versions of the Lattice SDK in all four languages:

• Lattice SDK for Go
• Lattice SDK for Java
• Lattice SDK for Javascript
• Lattice SDK for Python

This addresses an issue where the status component on the Entity was previously incorrectly modelled. If you were using this component, you will need to update your code to reference the new fields on the message.

The Lattice SDK for Java v3 introduces a number of changes:

• ⚠️ Breaking change - Alter how enum types are generated to support forward-compatible enums. These now follow a visitor pattern
• Fixes for SSE streaming

The Lattice SDK for Java 2.3.0 introduces a simplified approach for adding authentication headers to API requests:

• Added new addHeader method to the Lattice client builder that eliminates the need to create custom OkHttpClient instances.
• Updated all Java examples to use this new approach, resulting in cleaner, more maintainable code.
• Removed boilerplate OkHttpClient interceptor configuration that was previously required.

The new StreamEntities API provides several configurable parameters:

• preExistingOnly: Controls whether to stream only existing entities or include real-time updates.
• heartbeatIntervalMS: Configures how frequently the server sends heartbeat events.
• componentsToInclude: Allows filtering which entity components are streamed, reducing bandwidth usage and improving performance.

As a part of this release, Watch entities guide has been updated with code examples in all supported languages. Each example demonstrates both basic entity streaming and filtering specific components, providing common patterns for integrating real-time entity data into your Lattice apps.

The Lattice SDK introduces improved access to the Lattice SDK with REST support. Simply install the Lattice SDK in a language of your choice to get started building with Lattice:

The Lattice Protobuf definitions are now published, and available from the Buf Schema registry.

Use the Lattice protos and a plugin of your choice, to generate SDK artifacts for your language of choice. For more information, and to see an example in Go, see Generate the Lattice SDK for gRPC.

Lattice now supporting a resilient, distributed binary object store, letting you efficiently store binary data and relate them to entities in your environment. Some use cases include:

• Creating image thumbnails for tracks in the Lattice UI.
• Maintaining CSV data for entities for implementing vessel manifests, or other relevant entity metadata.