Changelog

Lattice Developer Console

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.

What’s new

• Entity Explorer: Browse, filter, and search every entity in your sandbox. Open one to inspect its components and tasks, and validate it against provided schemas to confirm it’s well-formed.

• Task Explorer: Browse every task and inspect its status, lifecycle, and payload.

• Object Explorer: Browse the objects stored in your sandbox.

The example C2 app remains available and is linked from the Developer Console as the Example C2 App.

To get started, see Lattice Sandboxes in the Lattice SDK guide.

Okta authentication for Lattice Sandboxes

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.

What’s new

• Okta account activation: New developers receive a welcome email from no-reply@developer.anduril.com with an Activate Okta Account link that expires seven days after it’s sent.
• Passkey-based MFA: During activation, you register one of three passkey methods:
  • Browser passkey: Stored by your browser’s password manager so that you can sign in from any device signed in to the same browser profile.
  • Operating system biometrics: Uses Touch ID, Face ID, Windows Hello, or another built-in platform authenticator bound to the current device.
  • Physical FIDO or UBI key: Uses a hardware token such as a YubiKey, which you can carry with you between devices.
• New sign-in URL: Sign in at https://login.developer.anduril.com. On success, Okta redirects you to the Lattice Sandboxes dashboard.
• Self-service passkey management: Manage your registered passkeys and password at https://login.developer.anduril.com/account-settings/home. If you lose access to your passkey, email lattice-developers@anduril.com for assistance.

For the full activation and sign-in procedures, see the Sign in section of the Lattice Sandboxes guide.

StreamTasks gRPC support

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

Key features

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.

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

Cancel tasks API

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.

For more information on using the CancelTask API in your integration, see Cancel tasks in the Lattice SDK guide.

For API reference details, see CancelTask (REST) and CancelTask (gRPC).

Server-sent events (SSE) for tasking

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:

• Filtering options: Focus on specific tasks using type prefix filtering.
• Heartbeat mechanism: Verify connection health with configurable heartbeat intervals.
• Comprehensive event data: Access full task details including status, description, and metadata.
• Efficient resource usage: Reduce network traffic and server load compared to polling.

StreamTasks

The StreamTasks API enables centralized monitoring of all tasks in your Lattice environment regardless of the assigned agent.

1
// Create task stream request
2
request := &Lattice.TaskStreamRequest{
3
    HeartbeatIntervalMs:     Lattice.Int(10000),
4
    ExcludePreexistingTasks: Lattice.Bool(false),
5
    TaskType: &Lattice.TaskStreamRequestTaskType{
6
        TaskStreamRequestTaskTypeTaskTypePrefix: &Lattice.TaskStreamRequestTaskTypeTaskTypePrefix{
7
            TaskTypePrefix: "type.googleapis.com/<your-organization>.tasks",
8
        },
9
    },
10
}
11
12
// Start the task stream
13
stream, err := LatticeClient.Tasks.StreamTasks(ctx, request)

StreamAsAgent

The StreamAsAgent API replaces the previous ListenAsAgent method, allowing agents to listen for tasks assigned specifically to them using server-sent events.

1
// Create agent stream request
2
agentRequest := &Lattice.AgentStreamRequest{
3
    AgentSelector: &Lattice.EntityIdsSelector{
4
        EntityIds: []string{entityId},
5
    },
6
}
7
8
// Start streaming tasks for the agent
9
agentStream, err := LatticeClient.Tasks.StreamAsAgent(ctx, agentRequest)

For more information about task monitoring, see Operate on tasks and Listen for tasks in the Lattice SDK guide.

OAuth 2.0 client credentials for Sandboxes

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.

Use OAuth 2.0 client credentials

You can find your Client ID and Client Secret in the Sandboxes UI under the Resource Credentials section:

• Lattice Client ID: This is a unique, public identifier associated with your integration.
• Lattice Client Secret: This is the secure credential your integration will use to authenticate with the Lattice environment, proving its identity.

In your integration, use the Lattice Client ID and Lattice Client Secret to submit requests to the API.

1
clientId := os.Getenv("LATTICE_CLIENT_ID")
2
clientSecret := os.Getenv("LATTICE_CLIENT_SECRET")
3
4
LatticeClient := client.NewClient(
5
    option.WithClientCredentials(clientID, clientSecret),
6
    option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
7
    option.WithHTTPHeader(headers),
8
)

For more information about setting up your development environment, see Set up in the Lattice SDK guide.

Updated SDKs

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

SDKs

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

New SDK Versions

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.

Java SDK v3

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

1
switch (event.getEventType().get()) {
2
    case EVENT_TYPE_PREEXISTING:
3
        System.out.println("Received pre-existing entity event");
4
        break;
5
    default:
6
        System.out.println("Default case");
7
        break;
8
}

Updated all Java examples to use the new addHeader method for adding authentication headers, simplifying how Sandbox authentication headers are set in Java applications.

1
--- java-client-before.java	2025-09-05 10:00:00
2
+++ java-client-after.java	2025-09-05 10:30:00
3
@@ -1,19 +1,11 @@
4
 import com.anduril.Lattice;
5
-import okhttp3.OkHttpClient;
6
 
7
 public class LatticeClientExample {
8
     public static void main(String[] args) {
9
         String endpoint = System.getenv("LATTICE_ENDPOINT");
10
         String token = System.getenv("ENVIRONMENT_TOKEN");
11
         String sandboxesToken = System.getenv("SANDBOXES_TOKEN");
12
-        
13
-        // Create HTTP client with Sandbox authentication
14
-        OkHttpClient httpClient = new OkHttpClient.Builder()
15
-            .addInterceptor(chain -> {
16
-                return chain.proceed(chain.request().newBuilder()
17
-                    .header("Anduril-Sandbox-Authorization", "Bearer " + sandboxesToken)
18
-                    .build());
19
-            })
20
-            .build();
21
-        
22
+
23
+        // Create Lattice client with Sandbox authentication
24
         Lattice client = Lattice.builder()
25
             .url(endpoint)
26
             .token(token)
27
-            .httpClient(httpClient)
28
+            .addHeader("Anduril-Sandbox-Authorization", "Bearer " + sandboxesToken)
29
             .build();
30
     }
31
 }

Java SDK Improvements

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.