# Trend Physics Pulse — AI repos + tools, scored (`brilliant_hemlock/trend-physics-pulse`) Actor

Daily AI-ecosystem snapshot: GitHub repo velocity + 🔴 star-bomb detection, an LLM-scored AI-tool registry, PyPI download spike signals, and topic-concentration leaders. Four data streams, one
Actor, flat dataset rows.

- **URL**: https://apify.com/brilliant\_hemlock/trend-physics-pulse.md
- **Developed by:** [Christian](https://apify.com/brilliant_hemlock) (community)
- **Categories:** AI, News, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Trend Physics Pulse

**Two AI-ecosystem trend signals you can't get from any single public API, shaped as flat Apify Dataset rows. $0.10 per 1000 rows.**

```json
{
  "_slice": "repos",
  "repo": "xai-org/x-algorithm",
  "anomaly_signal": "🔴 Star bomb (100x spike)",
  "composite_score": 1745.91,
  "velocity_per_day_7d": 124.43,
  "total_stars": 5791
}
````

☝️ One row from one run. Surfacing that without this Actor takes weeks of GitHub crawling plus your own anomaly logic. A default run gives you ~40 rows like it (across accelerating GitHub repos and a scored AI-tool registry) in under 2 seconds.

Two more slices — PyPI download velocity and topic-entropy / narrative-collapse — are in active development. See **Roadmap** at the bottom.

***

### Try it in 30 seconds

Easiest path: click **▶ Try for free** above — Apify runs the Actor in your browser with no setup.

For everyone else, grab an API token from [console.apify.com → Integrations](https://console.apify.com/account/integrations) and run any of these from a terminal:

```sh
export APIFY_TOKEN=apify_api_...
```

**1. Today's top accelerating repos**

```sh
curl -sX POST "https://api.apify.com/v2/acts/brilliant_hemlock~trend-physics-pulse/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"slices":["repos"],"limitPerSlice":50}' \
| jq -r '
    map(select(.composite_score != null))
    | sort_by(-.composite_score) | .[0:5][] |
    "\(.composite_score | floor)\t\(.repo)\t\(.anomaly_signal)"
  '
```

Expected output (one row = one accelerating repo, sorted by momentum):

```
1745   xai-org/x-algorithm                    🔴 Star bomb (100x spike)
 817   anthropics/claude-plugins-official    🟢 Normal variance
 115   HKUDS/CLI-Anything                     🟢 Normal variance
 100   microsoft/ai-agents-for-beginners      🟡 Suspicious spike (20x)
  88   langchain-ai/langgraph                 🟢 Normal variance
```

**2. Just the star-bombs — anything growing unnaturally fast today**

```sh
curl -sX POST "https://api.apify.com/v2/acts/brilliant_hemlock~trend-physics-pulse/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"slices":["repos"],"limitPerSlice":200}' \
| jq '[.[] | select(.anomaly_signal // "" | startswith("🔴"))]
       | .[] | {repo, anomaly_signal, total_stars, velocity_per_day_7d}'
```

**3. Top 5 useful AI-coding tools, formatted for a Slack digest**

```sh
curl -sX POST "https://api.apify.com/v2/acts/brilliant_hemlock~trend-physics-pulse/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"slices":["tools"],"limitPerSlice":50,"toolVerdict":"useful","toolCategory":"ai_coding"}' \
| jq -r '
    map(select(.avg_score != null))
    | sort_by(-.avg_score) | .[0:5][] |
    "*\(.canonical_name)* (score \(.avg_score)) — \(.one_liner)"
  '
```

Each call runs the Actor once on Apify's runners and returns the dataset rows in a single HTTP response — no polling, no dataset-URL juggling. Pipe straight into `jq`, `csvkit`, a Slack webhook, or a cron job.

***

### The two slices

Every row lands in the same Apify Dataset, tagged with `_slice` for filtering.

#### `repos` — accelerating GitHub repos

Backed by a multi-million-repo stargazer corpus with multi-year history. The Actor never calls GitHub itself — it requests precomputed signals from our backend. The repo cohort rotates daily, so each run surfaces a fresh set of accelerators.

```json
{
  "_slice": "repos",
  "repo": "anthropics/claude-plugins-official",
  "snapshot_day": "2026-05-23",
  "total_stars": 5729,
  "velocity_per_day_7d": 88.57,
  "acceleration_per_day_squared": 79.86,
  "anomaly_signal": "🟢 Normal variance",
  "composite_score": 817.38
}
```

Notable fields:

- **`composite_score`** — momentum score that weights acceleration against repo size. A fast-growing small repo can outrank a slow giant. Sort by this for the day's top movers.
- **`anomaly_signal`** — 🟢 Normal variance / 🟡 Suspicious spike / 🔴 Star bomb. Derived from each repo's historical star series, not just on-the-day spikes, so an old organic burst is distinguishable from a fresh coordinated one. Exact wording comes from the upstream materialised view — see METHODOLOGY.md for the burst-ratio thresholds.
- **`velocity_per_day_7d`, `acceleration_per_day_squared`** — first- and second-derivative momentum; week-over-week diff is built in.

#### `tools` — scored AI-tool registry

Curated registry refreshed by an internal LLM-rubric pipeline on a daily curation cycle. Each tool is scored 1–10 on novelty / utility / maturity / hype-vs-substance, with a written `verdict` (`useful` / `promising` / `noise`) and `justification`. Sources include GitHub Trending, HN, Reddit, and a handful of newsletters.

```json
{
  "_slice": "tools",
  "canonical_name": "TanStack Router",
  "category": "ai_infra",
  "verdict": "useful",
  "avg_score": 8.25,
  "novelty": 6, "utility": 9, "maturity": 9, "hype_vs_substance": 9,
  "one_liner": "A fully type-safe router and full-stack framework for building web applications with React and other frameworks.",
  "repo_url": "https://github.com/TanStack/router"
}
```

***

### What you'd use this for

- **Daily "what's moving" digest.** Sort `repos` by `composite_score` for the rotating top movers across the corpus.
- **Spot 100x star bombs the day they happen.** Filter `repos` where `anomaly_signal` starts with 🔴 — typically days before HN or X notice.
- **Weekly AI-tool Slack digest.** Filter `tools` by `verdict: useful` plus a `category`, push to your channel.
- **VC / scout pipeline.** Sort `repos` by `composite_score` and review small-but-accelerating projects worth a meeting.
- **Retire your own crawler.** GitHub polling + anomaly re-derivation + LLM tool scoring, replaced with one daily Actor run.

***

### Input

```json
{
  "slices": ["repos", "tools"],
  "limitPerSlice": 20,
  "repoMinStars": 1000,
  "toolVerdict": "useful",
  "toolCategory": ""
}
```

| Field | Default | Range / values | Purpose |
|---|---|---|---|
| `slices` | both | repos / tools | Uncheck to skip a slice and save spend. |
| `limitPerSlice` | 20 | 1–200 | Default keeps first-time runs cheap; raise to 200 for full daily dumps. |
| `repoMinStars` | 1000 | ≥0 | Drops low-noise repos. |
| `toolVerdict` | `useful` | any / useful / promising / noise | Filter `tools` by overall verdict. |
| `toolCategory` | — | e.g. `llm_framework`, `ai_coding` | Empty = all categories. |

***

### Pricing & limits

- **$0.10 per 1000 rows delivered** ($0.0001/row, Pay-Per-Event). A default ~40-row run ≈ **$0.004**; a maxed-out ~400-row run (`limitPerSlice: 200`) ≈ **$0.04**. Set `Maximum cost per run` in your run options to cap spend.
- 60 requests/minute per Apify customer (you won't hit it in normal use).
- Backend caches each filtered slice for 5 minutes per query.
- **Freshness**: repos refreshed within 24h (see `snapshot_day`); tools per daily curation cycle (see `scored_at`).

### What this is not

- Not a real-time API — refresh cadence above.
- Not a historical-query endpoint — time-series queries are planned for a higher-tier SKU.
- Not a GitHub or PyPI proxy — the corpus is curated and the signals are computed, not raw pass-through.

***

### Roadmap

Two more slices are wired into the backend but not yet exposed in this Actor's input — data pipeline work is still in progress:

- **`packages`** — PyPI download velocity per tracked LLM framework, with rolling average and spike-ratio signals.
- **`entropy`** — weekly Shannon-entropy analysis flagging AI subcategories that have concentrated onto a single leader repo.

They'll be added to `slices` once the underlying collectors are production-ready. METHODOLOGY.md tracks the current exposure status.

# Actor input Schema

## `slices` (type: `array`):

Which trend slices to include in this run. Both selected by default; uncheck to skip and save spend.

## `limitPerSlice` (type: `integer`):

Upper bound on rows returned per selected slice. Default 20 keeps a first-time run cheap; raise to 200 for full daily dumps.

## `repoMinStars` (type: `integer`):

Drop noise — only repos above this star threshold are returned.

## `toolVerdict` (type: `string`):

Filter the AI-tools slice by overall verdict. 'any' returns everything regardless of scoring.

## `toolCategory` (type: `string`):

e.g. llm\_framework, ai\_coding, ai\_design, local\_inference. Leave empty for all categories.

## Actor input object example

```json
{
  "slices": [
    "repos",
    "tools"
  ],
  "limitPerSlice": 20,
  "repoMinStars": 1000,
  "toolVerdict": "useful",
  "toolCategory": ""
}
```

# Actor output Schema

## `results` (type: `string`):

All rows from this run across selected slices. Each row carries `_slice` so you can filter downstream.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("brilliant_hemlock/trend-physics-pulse").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("brilliant_hemlock/trend-physics-pulse").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call brilliant_hemlock/trend-physics-pulse --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=brilliant_hemlock/trend-physics-pulse",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trend Physics Pulse — AI repos + tools, scored",
        "description": "Daily AI-ecosystem snapshot: GitHub repo velocity + 🔴 star-bomb detection, an LLM-scored AI-tool registry, PyPI download spike signals, and topic-concentration leaders. Four data streams, one\nActor, flat dataset rows.",
        "version": "0.1",
        "x-build-id": "AmBYYfXPtMDSz1kdH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/brilliant_hemlock~trend-physics-pulse/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-brilliant_hemlock-trend-physics-pulse",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/brilliant_hemlock~trend-physics-pulse/runs": {
            "post": {
                "operationId": "runs-sync-brilliant_hemlock-trend-physics-pulse",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/brilliant_hemlock~trend-physics-pulse/run-sync": {
            "post": {
                "operationId": "run-sync-brilliant_hemlock-trend-physics-pulse",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "slices": {
                        "title": "Slices to fetch",
                        "type": "array",
                        "description": "Which trend slices to include in this run. Both selected by default; uncheck to skip and save spend.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "repos",
                                "tools"
                            ],
                            "enumTitles": [
                                "GitHub repos (velocity + acceleration + anomaly)",
                                "AI tools (toolscout registry, scored 4 axes)"
                            ]
                        },
                        "default": [
                            "repos",
                            "tools"
                        ]
                    },
                    "limitPerSlice": {
                        "title": "Max items per slice",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Upper bound on rows returned per selected slice. Default 20 keeps a first-time run cheap; raise to 200 for full daily dumps.",
                        "default": 20
                    },
                    "repoMinStars": {
                        "title": "Repos: min total stars",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop noise — only repos above this star threshold are returned.",
                        "default": 1000
                    },
                    "toolVerdict": {
                        "title": "Tools: verdict filter",
                        "enum": [
                            "any",
                            "useful",
                            "promising",
                            "noise"
                        ],
                        "type": "string",
                        "description": "Filter the AI-tools slice by overall verdict. 'any' returns everything regardless of scoring.",
                        "default": "useful"
                    },
                    "toolCategory": {
                        "title": "Tools: category filter (optional)",
                        "type": "string",
                        "description": "e.g. llm_framework, ai_coding, ai_design, local_inference. Leave empty for all categories.",
                        "default": ""
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
