Smart Summarizer

Smart Summarizer

Summarize long content into a shorter, usable form without depending on an upstream LLM. This skill is built for agent workflows that need consistent structured output, not creative rewriting.

Free to use. Just create a Claw0x API key and call the skill.

Quick Reference

Why deterministic? Consistent output, no hallucination risk, fast processing, zero token costs.

5-Minute Quickstart

Step 1: Get API Key (30 seconds)

Sign up at claw0x.com → Dashboard → Create API Key

Step 2: Summarize Your First Text (1 minute)

curl -X POST https://api.claw0x.com/v1/call \
  -H "Authorization: Bearer ck_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "skill": "smart-summarizer",
    "input": {
      "text": "Long article text here...",
      "style": "bullet",
      "max_sentences": 3
    }
  }'

Step 3: Get Structured Summary (instant)

{
  "title": "Article Title",
  "summary": "Main summary text",
  "bullets": [
    "Key point 1",
    "Key point 2",
    "Key point 3"
  ],
  "keywords": ["keyword1", "keyword2"],
  "source_type": "text"
}

Step 4: Integrate Into Workflow (2 minutes)

// Add to research pipeline
const summary = await claw0x.call('smart-summarizer', {
  url: articleUrl,
  style: 'executive'
});

await db.articles.create({
  url: articleUrl,
  summary: summary.summary,
  bullets: summary.bullets,
  keywords: summary.keywords
});

Done. Your content is now summarized and structured.

Real-World Use Cases

Scenario 1: Research Agent Triage

Problem: Your agent needs to review 100+ articles and identify relevant ones

Solution:

1. Fetch article URLs from search results
2. Summarize each article
3. Extract keywords and key points
4. Filter by relevance
5. Deep-read only relevant articles

Example:

const articles = await searchEngine.query('AI agent frameworks');

const summaries = await Promise.all(
  articles.map(article =>
    claw0x.call('smart-summarizer', {
      url: article.url,
      style: 'brief',
      max_sentences: 3
    })
  )
);

// Filter by keywords
const relevant = summaries.filter(s =>
  s.keywords.some(k => ['agent', 'framework', 'automation'].includes(k))
);

// Result: Reduced 100 articles to 15 relevant ones in 2 minutes

Scenario 2: Email Digest Generation

Problem: Need to send daily digest of company news to team

Solution:

1. Collect news articles from RSS feeds
2. Summarize each article in bullet format
3. Combine into email digest
4. Send to team
5. Save time vs manual curation

Example:

def generate_daily_digest():
    articles = fetch_rss_feeds()
    
    summaries = []
    for article in articles:
        result = client.call("smart-summarizer", {
            "url": article["url"],
            "style": "bullet",
            "max_sentences": 3
        })
        summaries.append({
            "title": result["title"],
            "bullets": result["bullets"],
            "url": article["url"]
        })
    
    # Generate email
    email_body = format_digest(summaries)
    send_email(team_list, "Daily Digest", email_body)
    
    return len(summaries)
# Result: Automated daily digest, 2 hours saved per day

Scenario 3: Document Triage

Problem: Legal team has 500 contracts to review, need to prioritize

Solution:

1. Extract text from PDFs (using separate tool)
2. Summarize each contract
3. Extract key points and keywords
4. Rank by priority keywords
5. Review high-priority contracts first

Example:

async function triageContracts(pdfFiles) {
  const summaries = [];
  
  for (const pdf of pdfFiles) {
    // Extract text (using pdf-parser or similar)
    const text = await extractPdfText(pdf);
    
    // Summarize
    const summary = await claw0x.call('smart-summarizer', {
      document_text: text,
      title: pdf.name,
      style: 'executive',
      max_sentences: 5
    });
    
    // Check for priority keywords
    const isPriority = summary.keywords.some(k =>
      ['termination', 'liability', 'indemnity', 'breach'].includes(k)
    );
    
    summaries.push({ ...summary, priority: isPriority });
  }
  
  // Sort by priority
  return summaries.sort((a, b) => b.priority - a.priority);
}
// Result: Review 500 contracts in priority order, 80% time saved

Scenario 4: Meeting Notes Summarization

Problem: Team has long meeting transcripts, need quick summaries

Solution:

1. Get meeting transcript (from Zoom, Teams, etc.)
2. Summarize with action items focus
3. Extract key decisions and action items
4. Distribute to attendees
5. Track action items automatically

Example:

async function summarizeMeeting(transcriptUrl) {
  const summary = await claw0x.call('smart-summarizer', {
    url: transcriptUrl,
    style: 'executive',
    summary_type: 'action_items'
  });
  
  // Extract action items from bullets
  const actionItems = summary.bullets.filter(b =>
    b.toLowerCase().includes('action') || 
    b.toLowerCase().includes('todo') ||
    b.toLowerCase().includes('follow up')
  );
  
  // Create tasks
  for (const item of actionItems) {
    await taskManager.create({
      title: item,
      source: 'meeting',
      meeting_url: transcriptUrl
    });
  }
  
  // Send summary to attendees
  await sendEmail(attendees, 'Meeting Summary', {
    summary: summary.summary,
    action_items: actionItems,
    keywords: summary.keywords
  });
}
// Result: Automated meeting follow-up, 100% action item tracking

Integration Recipes

OpenClaw Agent

import { Claw0xClient } from '@claw0x/sdk';

const claw0x = new Claw0xClient(process.env.CLAW0X_API_KEY);

// Summarize articles in research workflow
agent.onCommand('research', async (topic) => {
  const articles = await searchEngine.query(topic);
  
  const summaries = await Promise.all(
    articles.map(article =>
      claw0x.call('smart-summarizer', {
        url: article.url,
        style: 'brief'
      })
    )
  );
  
  return summaries;
});

LangChain Agent

from claw0x import Claw0xClient
import os

client = Claw0xClient(api_key=os.getenv("CLAW0X_API_KEY"))

def summarize_document(text, style='bullet'):
    result = client.call("smart-summarizer", {
        "text": text,
        "style": style,
        "max_sentences": 5
    })
    
    return {
        "summary": result["summary"],
        "bullets": result["bullets"],
        "keywords": result["keywords"]
    }

# Use in document processing chain
summary = summarize_document(long_text)

Content Pipeline (Generic HTTP)

async function processArticle(url) {
  const response = await fetch('https://api.claw0x.com/v1/call', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.CLAW0X_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      skill: 'smart-summarizer',
      input: {
        url,
        style: 'executive',
        max_sentences: 5
      }
    })
  });
  
  const result = await response.json();
  
  // Store in CMS
  await cms.create({
    original_url: url,
    title: result.title,
    summary: result.summary,
    bullets: result.bullets,
    keywords: result.keywords
  });
}

Batch Processing

// Summarize multiple documents
const documents = await db.documents.findMany({ 
  status: 'pending_summary' 
});

const summaries = await Promise.all(
  documents.map(doc =>
    claw0x.call('smart-summarizer', {
      text: doc.content,
      title: doc.title,
      style: 'bullet',
      max_sentences: 5
    })
  )
);

// Update database
for (let i = 0; i < documents.length; i++) {
  await db.documents.update({
    where: { id: documents[i].id },
    data: {
      summary: summaries[i].summary,
      bullets: summaries[i].bullets,
      keywords: summaries[i].keywords,
      status: 'summarized'
    }
  });
}

Deterministic vs LLM Summarization: Which is Right for You?

When to Use LLM-Based

• Need creative rephrasing
• Want natural language flow
• Summarizing creative content
• Need semantic understanding

When to Use Smart Summarizer (Deterministic)

• Need reproducible results
• Want fast processing (sub-second)
• Processing thousands of documents
• Cost-sensitive applications
• Need structured JSON output
• Extractive summary is sufficient

How It Fits Into Your Content Workflow

┌─────────────────────────────────────────────────────────────┐
│                  Content Processing Pipeline                 │
└─────────────────────────────────────────────────────────────┘
                            │
                            ├─ Content Ingestion
                            │  • RSS feeds
                            │  • Web scraping
                            │  • Document uploads
                            │
                            ├─ Summarization
                            │  POST /v1/call
                            │  {text/url/document_text, style, max_sentences}
                            │
                            ├─ Structured Output
                            │  • Summary text
                            │  • Bullet points
                            │  • Keywords
                            │  • Metadata
                            │
                            └─ Distribution
                               • Email digests
                               • Dashboard updates
                               • Database storage

Integration Points

1. Research Triage — Quick review of many articles
2. Email Digests — Daily/weekly content summaries
3. Document Processing — Bulk summarization
4. Content Curation — Filter by keywords
5. Meeting Notes — Extract action items

Why Use This Via Claw0x?

Unified Infrastructure

• One API key for all skills — no per-provider auth
• Atomic billing — pay per successful call, $0 on failure (currently free)
• Security scanned — OSV.dev integration for all skills

Summarization-Optimized

• Deterministic — reproducible, auditable results
• Fast processing — sub-second summarization
• Structured output — JSON format with bullets, keywords, metadata
• Multiple input modes — text, URL, or document_text

Production-Ready

• 99.9% uptime — reliable infrastructure
• Scales to millions — handle enterprise-scale summarization
• Cloud-native — works in Lambda, Cloud Run, containers
• Zero dependencies — no LLM API keys required

What It Does

• Summarizes raw text
• Summarizes a public URL by fetching readable page content
• Summarizes document content when the document text is already extracted upstream
• Returns a short summary plus bullet points and metadata

Real-World Use Cases

Scenario 1: Research Agent Triage

Problem: Your agent needs to review 100+ articles and identify relevant ones

Solution:

1. Fetch article URLs from search results
2. Summarize each article
3. Extract keywords and key points
4. Filter by relevance
5. Deep-read only relevant articles

Example:

const articles = await searchEngine.query('AI agent frameworks');

const summaries = await Promise.all(
  articles.map(article =>
    claw0x.call('smart-summarizer', {
      url: article.url,
      style: 'brief',
      max_sentences: 3
    })
  )
);

// Filter by keywords
const relevant = summaries.filter(s =>
  s.keywords.some(k => ['agent', 'framework', 'automation'].includes(k))
);

// Result: Reduced 100 articles to 15 relevant ones in 2 minutes

Scenario 2: Email Digest Generation

Problem: Need to send daily digest of company news to team

Solution:

1. Collect news articles from RSS feeds
2. Summarize each article in bullet format
3. Combine into email digest
4. Send to team
5. Save time vs manual curation

Example:

def generate_daily_digest():
    articles = fetch_rss_feeds()
    
    summaries = []
    for article in articles:
        result = client.call("smart-summarizer", {
            "url": article["url"],
            "style": "bullet",
            "max_sentences": 3
        })
        summaries.append({
            "title": result["title"],
            "bullets": result["bullets"],
            "url": article["url"]
        })
    
    # Generate email
    email_body = format_digest(summaries)
    send_email(team_list, "Daily Digest", email_body)
    
    return len(summaries)
# Result: Automated daily digest, 2 hours saved per day

Scenario 3: Document Processing Pipeline

Problem: Legal team has 500 contracts to review, need quick summaries

Solution:

1. Extract text from PDFs (using separate tool)
2. Summarize each contract
3. Extract key points and keywords
4. Rank by priority keywords
5. Review high-priority contracts first

Example:

async function processContracts(pdfFiles) {
  const summaries = [];
  
  for (const pdf of pdfFiles) {
    // Extract text (using pdf-parser)
    const text = await extractPdfText(pdf);
    
    // Summarize
    const summary = await claw0x.call('smart-summarizer', {
      document_text: text,
      title: pdf.name,
      style: 'executive',
      max_sentences: 5
    });
    
    // Check for priority keywords
    const isPriority = summary.keywords.some(k =>
      ['termination', 'liability', 'indemnity', 'breach'].includes(k)
    );
    
    summaries.push({ ...summary, priority: isPriority, file: pdf.name });
  }
  
  // Sort by priority
  return summaries.sort((a, b) => b.priority - a.priority);
}
// Result: Review 500 contracts in priority order, 80% time saved

Scenario 4: Content Curation

Problem: Content team needs to curate relevant articles for newsletter

Solution:

1. Scrape articles from multiple sources
2. Summarize each article
3. Extract keywords for categorization
4. Filter by topic relevance
5. Auto-generate newsletter draft

Example:

async function curateNewsletter(sources, topic) {
  const articles = await scrapeMultipleSources(sources);
  
  const summaries = await Promise.all(
    articles.map(article =>
      claw0x.call('smart-summarizer', {
        url: article.url,
        style: 'bullet',
        max_sentences: 4
      })
    )
  );
  
  // Filter by topic keywords
  const relevant = summaries.filter(s =>
    s.keywords.some(k => topic.keywords.includes(k))
  );
  
  // Generate newsletter
  const newsletter = {
    title: `${topic.name} Weekly Digest`,
    sections: relevant.map(s => ({
      title: s.title,
      summary: s.summary,
      bullets: s.bullets,
      source_url: s.source_url
    }))
  };
  
  return newsletter;
}
// Result: Automated weekly newsletter, 5 hours saved per week

Integration Recipes

OpenClaw Agent

import { Claw0xClient } from '@claw0x/sdk';

const claw0x = new Claw0xClient(process.env.CLAW0X_API_KEY);

// Summarize in research workflow
agent.onCommand('summarize', async (url) => {
  const result = await claw0x.call('smart-summarizer', {
    url,
    style: 'executive'
  });
  
  return {
    summary: result.summary,
    bullets: result.bullets,
    keywords: result.keywords
  };
});

LangChain Agent

from claw0x import Claw0xClient
import os

client = Claw0xClient(api_key=os.getenv("CLAW0X_API_KEY"))

def summarize_for_research(url):
    result = client.call("smart-summarizer", {
        "url": url,
        "style": "brief",
        "max_sentences": 3
    })
    
    return result["summary"]

# Use in research chain
summary = summarize_for_research(article_url)

Content Pipeline (Generic HTTP)

async function summarizeArticle(text, style = 'bullet') {
  const response = await fetch('https://api.claw0x.com/v1/call', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.CLAW0X_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      skill: 'smart-summarizer',
      input: { text, style, max_sentences: 5 }
    })
  });
  
  const result = await response.json();
  return result;
}

Batch Processing

// Summarize multiple documents
const documents = await db.documents.findMany({ 
  status: 'pending_summary' 
});

const summaries = await Promise.all(
  documents.map(doc =>
    claw0x.call('smart-summarizer', {
      text: doc.content,
      title: doc.title,
      style: 'bullet',
      max_sentences: 5
    })
  )
);

// Update database
for (let i = 0; i < documents.length; i++) {
  await db.documents.update({
    where: { id: documents[i].id },
    data: {
      summary: summaries[i].summary,
      bullets: summaries[i].bullets,
      keywords: summaries[i].keywords,
      status: 'summarized'
    }
  });
}

What It Does

Why This V1 Is Narrower Than The Name

The marketplace pitch says "text, URL, or document", but a free deterministic skill should not pretend to parse every file format. In this version:

• text is fully supported
• url is fully supported for public HTML or plain text pages
• document_text is supported when another step already extracted the document's text

This avoids hidden upstream AI costs and keeps the skill reliable enough to list as a free utility.

When To Use

• Research agents need a first-pass summary of an article or note
• Email digest workflows need a compact brief
• Document triage needs quick key points before deeper review
• Agents want stable JSON output instead of free-form paragraphs

Input

Provide exactly one source field.

Output Fields

Example

Input

{
  "input": {
    "text": "Smart summarization is useful when teams need a fast first-pass review of long internal documents. It helps operators triage what matters, extract the main decisions, and skip repetitive detail. It is especially useful in research workflows where many articles must be screened before deep reading.",
    "style": "bullet",
    "max_sentences": 3
  }
}

Output

{
  "title": "Smart summarization is useful when teams need a fast first-pass review of long internal documents.",
  "summary": "- Smart summarization is useful when teams need a fast first-pass review of long internal documents.\n- It helps operators triage what matters, extract the main decisions, and skip repetitive detail.\n- It is especially useful in research workflows where many articles must be screened before deep reading.",
  "bullets": [
    "Smart summarization is useful when teams need a fast first-pass review of long internal documents.",
    "It helps operators triage what matters, extract the main decisions, and skip repetitive detail.",
    "It is especially useful in research workflows where many articles must be screened before deep reading."
  ],
  "source_type": "text",
  "keywords": ["documents", "research", "workflows"]
}

Error Codes

• 400 Missing input, multiple source fields, invalid URL, or unreadable content
• 401 Missing or invalid Claw0x API key
• 502 URL fetch failed
• 500 Internal processing error

Pricing

Free. No upstream provider key required.