Amp API Awareness

Amp API Awareness

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

Data Sources

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

MCP Servers

Agent Modes

• smart: 2,398 threads (99%)
• rush: 1 thread
• nil: 25 threads

Known Endpoints & APIs

CLI Commands

Visibility Levels

User ID Format

From find_thread API:

creatorUserID: "user_01JZZT0P50CFR9XKKW8SXQ7J74"

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

Workspace Member Discovery

Query workspace threads to find all creatorUserID values:

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

Example: Two users discovered in workspace i:

Local Storage

Environment Variables

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

Thread Usage Distribution (from 2,424 threads)

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.