Amp API Awareness

Discover Amp's undocumented API by mining local thread storage.

Data Sources

~/.local/share/amp/threads/*.json

~/.claude/history.jsonl

~/.claude/projects/*/*.jsonl

Quick Extraction

Count all threads

ls ~/.local/share/amp/threads/*.json | wc -l

Sample thread structure

cat ~/.local/share/amp/threads/T-*.json | head -1 | jq 'keys'
# Expected: ["id", "title", "created", "updatedAt", "messages", ...]

DuckDB unified query

-- Load all threads
CREATE TABLE amp_threads AS
SELECT * FROM read_json('~/.local/share/amp/threads/*.json', 
  columns={id: 'VARCHAR', title: 'VARCHAR', created: 'BIGINT', 
           messages: 'JSON[]', creatorUserID: 'VARCHAR'},
  ignore_errors=true);

-- Extract message patterns
SELECT 
  id,
  title,
  len(messages) as msg_count,
  abs(hash(id)) % 3 - 1 as trit
FROM amp_threads
ORDER BY created DESC
LIMIT 20;

API Discovery Patterns

1. Tool Usage Extraction

-- Find all tool invocations across threads
SELECT 
  json_extract_string(msg, '$.type') as msg_type,
  json_extract_string(msg, '$.name') as tool_name,
  count(*) as usage_count
FROM amp_threads, unnest(messages) as t(msg)
WHERE json_extract_string(msg, '$.type') = 'tool_use'
GROUP BY 1, 2
ORDER BY usage_count DESC;

2. MCP Server Detection

-- Extract MCP patterns from content
SELECT DISTINCT
  regexp_extract(content, 'mcp__([a-z_]+)__', 1) as mcp_server
FROM (
  SELECT json_extract_string(msg, '$.content') as content
  FROM amp_threads, unnest(messages) as t(msg)
)
WHERE mcp_server IS NOT NULL;

3. Thread Schema Discovery

// TypeScript extraction from thread JSON
interface AmpThread {
  id: string;           // T-{uuid}
  title: string;
  created: number;      // Unix timestamp ms
  updatedAt: string;    // ISO8601
  creatorUserID: string;
  messages: AmpMessage[];
}

interface AmpMessage {
  role: 'user' | 'assistant';
  content: ContentBlock[];
}

type ContentBlock = 
  | { type: 'text'; text: string }
  | { type: 'thinking'; thinking: string }
  | { type: 'tool_use'; id: string; name: string; input: unknown }
  | { type: 'tool_result'; tool_use_id: string; content: string };

Full Statistics (2,424 threads, 118,951 messages)

Core Tools

Bash

Read

edit_file

create_file

todo_write

Grep

skill

Task

glob

mermaid

find_thread

read_thread

MCP Servers

firecrawl

firecrawl_scrape

exa

web_search_exa

gay

palette

next_color

deepwiki

ask_question

beeper

list_messages

radare2

huggingface

tree_sitter

Agent Modes

• smart

  : 2,398 threads (99%)

• rush

  : 1 thread

• nil

  : 25 threads

Known Endpoints & APIs

ampcode.com/threads/T-*

ampcode.com/settings

find_thread

creatorUserID

read_thread

CLI Commands

amp threads list

amp threads share --visibility <v>

amp threads share --support

amp login

amp logout

amp skill list/add/remove

amp mcp list/add/remove

Visibility Levels

private

workspace

group

public

unlisted

User ID Format

From

find_thread

creatorUserID: "user_01JZZT0P50CFR9XKKW8SXQ7J74"

• Prefix:

  user_

• Body: 26-char ULID-like identifier (TypeID format)

Workspace Member Discovery

Query workspace threads to find all

creatorUserID

# Via find_thread DSL (repo: filter scopes to workspace)
find_thread "repo:i after:30d"

Example: Two users discovered in workspace

i

user_01JZZT0P50CFR9XKKW8SXQ7J74

user_01K5ESNNPKQ43J06VRC1TS5AX0

Local Storage

~/.local/share/amp/secrets.json

apiKey@https://ampcode.com/

~/.local/share/amp/session.json

agentMode

~/.local/share/amp/threads/*.json

~/.config/amp/settings.json

Environment Variables

AMP_API_KEY

AMP_URL

AMP_SETTINGS_FILE

GF(3) Classification

Threads are colored by hash:

abs(hash(id)) % 3 - 1 as trit
-- -1 = MINUS (validation threads)
--  0 = ERGODIC (coordination)
-- +1 = PLUS (generation)

Usage

# Export to DuckDB
duckdb amp-threads.duckdb -c "
  CREATE TABLE threads AS 
  SELECT * FROM read_json('~/.local/share/amp/threads/*.json', 
    ignore_errors=true);
"

# Query patterns
duckdb amp-threads.duckdb -c "
  SELECT title, created FROM threads 
  ORDER BY created DESC LIMIT 10;
"

Underlying LLM Cost Estimates (Jan 2026)

Amp uses multiple LLMs. Pricing per 1M tokens (input/output):

Claude 4.5 Series (Anthropic)

Sonnet 4.5 >200K context: $6/$22.50 per 1M tokens

Gemini 3 Series (Google)

Amp Mode → Model Mapping

smart

rush

large

Thread Usage Distribution (from 2,424 threads)

claude-opus-4-5-20251101

gemini-3-pro-preview

claude-sonnet-4-20250514

claude-haiku-4-5-20251001

Cost Optimizations Available

Amp Pricing Pass-Through

Amp passes LLM costs directly with no markup for individuals/teams.

• Free tier: $10/day grant (all modes including Opus 4.5)
• Enterprise: +50% over individual/team rates

Example Cost Calculation

Typical thread (~50 messages, 100K tokens total):

Opus 4.5: ~$1.50/thread (50K in × $5 + 50K out × $25)
Haiku 4.5: ~$0.30/thread (80% savings)
Gemini 3 Pro: ~$0.70/thread (mid-tier)

Related Skills

• duckdb-ies

  - IES analytics layer

• amp-team-usage

  - Team/session tracking

• unified-reafference

  - Cross-agent session DB

SDF Interleaving

This skill connects to Software Design for Flexibility (Hanson & Sussman, 2021):

Primary Chapter: 10. Adventure Game Example

Concepts: autonomous agent, game, synthesis

GF(3) Balanced Triad

amp-api-awareness (−) + SDF.Ch10 (+) + [balancer] (○) = 0

Skill Trit: -1 (MINUS - verification)

Secondary Chapters

• Ch2: Domain-Specific Languages
• Ch9: Generic Procedures
• Ch8: Degeneracy
• Ch4: Pattern Matching
• Ch5: Evaluation
• Ch6: Layering

Connection Pattern

Adventure games synthesize techniques. This skill integrates multiple patterns.