# ElizaOS Developer Update: August 14, 2025

## Core Framework

This week marked a significant architectural discussion about ElizaOS's future direction. The team debated the core design philosophy, with Shaw defending the current architecture as a social agent framework with intentional tradeoffs rather than primarily a tool-calling framework.

```typescript
// Upcoming improvements to core runtime with better streaming
const coreRuntime = {
  streaming: true,
  browserCompatible: true,
  simpleToolCalling: true
};

// Future approach to agent communication
const rolodexSystem = {
  crossPlatform: true,
  trustedCommunication: true,
  allowAgentToMessageAnyone: true
};
```

Major framework developments:
- A Hono server has been integrated with an OpenAI-compatible API
- Agent registry has been overhauled for improved agent management
- Ongoing development of ElizaOS v3 with streamlined directory structure and faster build times (75ms)
- New character type system using Zod validation for consistent API interactions

## New Features

### Sessions API

A new Sessions API has been introduced, providing a simplified interface for managing conversations between users and agents:

```typescript
// Example of using the new Sessions API
const api = new ElizaClient({ apiKey: 'your-api-key' });
const session = await api.sessions.create({
  agentId: 'agent-uuid',
  userId: 'user-123',
  metadata: { context: 'support' }
});

// Send a message in the session
const response = await api.sessions.sendMessage(session.id, {
  content: "How can I build an agent that trades crypto?",
  userId: 'user-123'
});

console.log(response.content); // Agent's response
```

### EVM Plugin

A new Ethereum Virtual Machine plugin has been added, providing essential wallet and blockchain tooling:

```typescript
// Example of EVM plugin usage
const wallet = runtime.useAction('evm.getWalletAddress');
const balance = runtime.useAction('evm.getWalletBalance');

// Check token balance
async function checkTokenBalance(address, chain = "ethereum") {
  const result = await runtime.callAction('evm.getTokenBalance', { 
    address, 
    chain, 
    token: "USDC" 
  });
  return result.balance;
}
```

### Clank Tank 2.0

Jin introduced "Clank Tank 2.0," a governance platform combining elements of Shark Tank, AI prediction markets, and DAO governance:

- Features AI judges representing different archetypes (casual, quant, degen, builder)
- Technical implementation includes client-side rendering with PlayCanvas
- Currently in V2 beta testing with improved graphics, animation, and reasoning logic

## Bug Fixes

Several critical bugs were addressed this week:

1. **Plugin Publishing Issues**: Fixed the `elizaos publish` command which was falsely reporting success even when package publishing failed (PR #5763)
   
   ```bash
   # Before: Would falsely report success
   elizaos publish --npm
   
   # After: Properly validates actual publishing status
   elizaos publish --npm --test
   ```

2. **CLI Build Failure**: Investigating issue #5734 where ElizaOS CLI fails to build projects with TypeScript errors

3. **Agent Start Hanging**: Resolved an issue where the `startAgent` function would hang when the bootstrap plugin was omitted or included (issue #5719)

4. **Memory Count Errors**: Fixed the `clearAgentMemories` command to use `result?.deletedCount` instead of `result?.deleted` for proper display of cleared memories

5. **Action Chaining**: Fixed issues with proper action chaining in PR #5736

## API Changes

### Chat Completions API

The chat completions API has been updated to expose intermediate tool calls while maintaining full OpenAI API compliance:

```typescript
// New option to expose tool calls in chat completions response
const response = await api.chat.completions.create({
  model: "eliza-1",
  messages: [{ role: "user", content: "What's the weather in NYC?" }],
  expose_tool_calls: true  // Shows intermediate tool calls
});

// Tool calls are now visible in the response
console.log(response.tool_calls);
```

### Sessions API Client Integration

The Sessions API has been integrated into the `@elizaos/api-client` package:

```typescript
import { ElizaClient } from '@elizaos/api-client';

// Initialize client
const client = new ElizaClient({
  baseURL: 'http://localhost:3000',
  apiKey: 'your-api-key'
});

// Create a new session
const session = await client.sessions.create({
  agentId: 'agent-uuid',
  userId: 'user-123'
});

// List all sessions
const sessions = await client.sessions.list();
```

## Social Media Integrations

The team is actively working on recovering the suspended ElizaOS Twitter account (@elizawakesup). In the meantime, a multi-channel marketing strategy is being implemented across Farcaster, LinkedIn, TikTok, and YouTube.

Users reported issues with:
- Twitter rate limiting after reconfiguring agents
- Telegram bot conflict errors (409: Conflict) when setting up support agents
- Bridge between Telegram and Discord experiencing glitches and reposting old messages

To address these challenges, the team is exploring Farcaster miniapps as a potential new distribution channel.

## Model Provider Updates

Work continues on improving model provider integrations:

1. **OpenAI API Compatibility**: ElizaOS now offers an OpenAI-compatible API through the new Hono server implementation

2. **Context Caching**: Development of context caching for autonomous agents to improve performance with large context windows

3. **Benchmarking Initiative**: Implementation of TAU-bench, AgentBench, and typewriter tests to measure agent performance objectively

4. **Streaming Support**: Enhanced streaming implementation that's more browser compatible

## Breaking Changes

As we move toward V2/V3, developers should be aware of these upcoming changes:

1. **Directory Structure**: Moving from `/packages` to `/lib`, and `/actions` to `/tools` which will require path updates in imports

2. **Message Server Architecture**: Separating message server from agent implementation with a shift from socket.io to websockets

3. **Tool Calling**: The emphasis on character and personality currently adds noise that makes the system less efficient at direct tool calling tasks like code agents

4. **XML Handling**: Replaced unsafe XML fallback regex with linear scan to avoid catastrophic backtracking

5. **Plugin System**: Working on making the validate function for actions optional while ensuring developers properly limit available actions

```typescript
// Future direct tool calling without wrappers
// Current approach
const result = await runtime.callAction('github.searchIssues', { 
  query: 'is:open label:bug' 
});

// Future approach
const github = runtime.tools.github;
const result = await github.searchIssues('is:open label:bug');
```

Developers are advised to follow the #core-devs channel on Discord for more detailed migration guides as we approach the V2/V3 transition.