# January 30, 2026 Update

Week 49 Demo Day: Open Code Plugin, Overnight Game Builder & more - YouTube

Agentuity183 subscribers

It's been a minute since our last changelog — we've been heads-down polishing the platform for v1. This update covers everything we've shipped since [January 7](/content/blog/agentuity-v1-reaches-beta/index.html): **12 releases** and **235 commits**. There's a lot to cover, so let's dive in.

## Overview

Here's what's new at a glance:

- _OpenCode plugin_ with a team of AI agents for your editor
- _Queue system_ for background job processing
- _Sandbox snapshots_ with encryption and public sharing
- _TTL support_ across KV, Vector, and Streams
- [And more!](/content/blog/january-30-2026-update#also-shipping/index.html)

Read on for the details.

## OpenCode Plugin

The new `@agentuity/opencode` package brings a team of specialized AI agents to [OpenCode](https://opencode.ai/). Install it and you get commands for orchestrating tasks, accessing cloud services, and running code in sandboxes — all from your editor.

```
agentuity ai opencode install
```

Once installed, use commands to interact with the agent team:

```
/agentuity-coder implement dark mode for settings page
/agentuity-cloud list all my KV namespaces
/agentuity-sandbox run bun test in a sandbox
```

The plugin includes six specialized agents:

| Agent      | Role                                              |
|------------|---------------------------------------------------|
| **Lead**   | Orchestrates tasks, delegates to the team         |
| **Scout**  | Explores codebases, finds patterns (read-only)   |
| **Builder**| Implements features, runs tests, uses sandboxes   |
| **Reviewer**| Reviews code, catches issues, applies fixes      |
| **Memory** | Maintains context via KV/Vector storage            |
| **Expert** | CLI, SDK, and cloud services specialist            |

For long-running tasks, **Cadence mode** lets the team work autonomously across multiple iterations:

```
/agentuity-cadence implement the payment integration with Stripe, including tests and docs
```

Lead will create checkpoints, delegate to Scout, Builder, and Reviewer as needed, and continue until the task is complete. You can pause, resume, and monitor progress via natural language or the CLI:

```
# Monitor running cadence loops
agentuity ai cadence list
agentuity ai cadence status lp_auth_01

# Control
agentuity ai cadence pause lp_auth_01
agentuity ai cadence resume lp_auth_01
```

## Cloud Services

### Queue System

The queue service is now fully available in both the SDK and CLI. Queues handle background job processing with automatic retries and dead-letter support.

```javascript
// Publish a message (async by default)
await ctx.queue.publish('email-queue', {
  to: 'user@example.com',
  subject: 'Welcome!',
});

// Publish and wait for acknowledgment
await ctx.queue.publish('critical-queue', payload, { sync: true });
```

From the CLI:

```
# Publish a message
agentuity cloud queue publish email-queue '{"to": "user@example.com"}'

# Publish synchronously (blocks until acknowledged)
agentuity cloud queue publish email-queue '{"to": "user@example.com"}' --sync
```

### Sandbox Snapshots

[Snapshots](https://agentuity.dev/services/sandbox/snapshots) let you save the state of a [sandbox](https://agentuity.dev/services/sandbox) and restore it later — or share it with others. We've also added encryption, public sharing, and virus scanning.

```javascript
const sandbox = await ctx.sandbox.create({ runtime: 'bun:1' });
await sandbox.execute({ command: ['bun', 'init'] });
await sandbox.execute({ command: ['bun', 'add', 'zod', 'hono'] });

// Save the state
const snapshot = await ctx.sandbox.snapshot.create(sandbox.id);

// Later: restore from snapshot
const restored = await ctx.sandbox.create({ snapshot: snapshot.id });
```

From the CLI:

```
agentuity cloud sandbox snapshot create <sandbox-id>           # encrypted by default
agentuity cloud sandbox snapshot create <sandbox-id> --public  # make publicly accessible
```

### TTL Support

You can now set expiration times on [key-value](https://agentuity.dev/services/storage/key-value) entries, vector records, and [streams](https://agentuity.dev/services/storage/durable-streams). Data automatically expires after the TTL.

```javascript
// KV with TTL (expires in 1 hour)
await ctx.kv.set('cache', 'session:123', data, { ttl: 3600 });

// Vector with TTL (24 hours)
await ctx.vector.upsert('memories', {
  key: 'mem_123',
  document: 'User prefers dark mode',
  ttl: 86400,
});

// Stream with TTL (7 days)
const stream = await ctx.stream.create('logs', { ttl: 604800 });
```

## SDK Improvements

### Schema Strict Mode

[`@agentuity/schema`](https://agentuity.dev/agents/schema-libraries#using-agentuityschema) now supports a `strict` option for generating JSON schemas compatible with OpenAI's structured output mode:

```javascript
import { s } from '@agentuity/schema';

const schema = s.object({
  name: s.string(),
  age: s.number(),
});

// Strict mode for OpenAI/Groq structured output
const strict = schema.toJSONSchema({ strict: true });
// Adds "additionalProperties": false at every level
```

### Eval Lifecycle Hooks

[Preset evals](https://agentuity.dev/agents/evaluations) now support `onStart` and `onComplete` hooks for logging, metrics, or setup/cleanup:

```javascript
import { politeness } from '@agentuity/evals';

const agent = createAgent('assistant', {
  handler: async (ctx, input) => {
    // ...
  },
});

agent.createEval(
  'politeness-check',
  politeness({
    onStart: (ctx, input) => {
      ctx.logger.info('[EVAL] politeness: Starting', { request: input.request });
    },
    onComplete: (ctx, input, output, result) => {
      ctx.logger.info('[EVAL] politeness: Completed', {
        passed: result.passed,
        reason: result.reason,
      });
    },
  })
);
```

### Sandbox Output Capture

`sandbox.run()` now captures and returns stdout/stderr in the result object:

```javascript
const result = await ctx.sandbox.run({
  runtime: 'bun:1',
  command: {
    exec: ['bun', 'run', '-e', 'console.log("Hello"); console.error("Oops")'],
  },
});

console.log(result.stdout); // "Hello\n"
console.log(result.stderr); // "Oops\n"
```

Output streams in real time and is captured for programmatic access. We also switched to server-side long-polling for more reliable execution status.

### Also New

- **SSE + AI SDK** — SSE handlers now work with `generateText`/`generateObject`
- **`waitUntil()`** — Available directly on route context
- **Standalone agents** — Auto-initialization with `ctx.run()`
- **Dynamic path params** — Support in `useAPI().invoke()`

## CLI and Tooling

### Performance

The `agentuity --version` command is now **18x faster**, dropping from ~1.3s to ~70ms. Project data and region caching reduce duplicate API calls across all commands.

### Support Command

New `agentuity support` command for diagnostics:

```
agentuity support report     # Generate a support report
agentuity support logs show  # View recent logs
agentuity support system     # System information
```

### Auth Refactoring

`auth machine` is now `auth org` with clearer subcommands:

```
agentuity auth org enroll    # Set up org authentication
agentuity auth org unenroll  # Remove public key
agentuity auth org status    # Show current key
```

### VS Code Extension

- **Sandbox Explorer** — Create, list, execute commands, and destroy sandboxes from the sidebar
- **Queue Explorer** — View queues, publish test messages, inspect dead-letter queues
- **VSIX in releases** — Extension published alongside the SDK

### Also New

- **Debugger support** — Attach a debugger to `agentuity dev`
- **Agent detection** — CLI detects coding agents (Cursor, Claude Code, OpenCode, and more)
- **Region detection** — Confirmation prompt when deploying to a different region
- **Org-level secrets** — Environment variables and secrets at the org level

## Also Shipping

Beyond the highlights above, here's what else shipped:

**Storage & Services**

- `vector.exists()` correctly returns false for empty namespaces
- Database descriptions in list/get commands

**Bug Fixes**

- Improved malware detection to resolve npm package aliases
- Fixed ReadableStream error in SSE handlers with AI SDK
- Fixed sandbox client pipe output loss
- Handle 421 Misdirected Request for cross-region resources
- Prevented internal logger race conditions in forked processes
- Fixed route type generation for folder-based agents

## Upgrade Now

Ready to try it out? Run:

```
agentuity upgrade
```

Or if you're starting fresh:

```
curl -fsSL https://agentuity.sh | sh
```

Once you're upgraded, try a few of the new features:

- Install the OpenCode plugin with `agentuity ai opencode install`
- Create a queue with `agentuity cloud queue create`
- Add TTL to your KV entries with the `ttl` option

Questions or feedback? Drop by [our Discord](https://discord.gg/agentuity) to chat. Happy building!