# AI Capability Unlock Feed (`jp-public-data/ai-capability-unlock-feed`) Actor

Official OpenAI, Google, and Anthropic capability-announcement candidates for AI agents, with source links, deduplication, and cautious availability labels.

- **URL**: https://apify.com/jp-public-data/ai-capability-unlock-feed.md
- **Developed by:** [株式会社MaSANO Vida](https://apify.com/jp-public-data) (community)
- **Categories:** AI, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.05 / successful capability report

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## AI Capability Unlock Feed — v0.4

A standalone Apify Actor that emits **candidate** opportunities from official AI product announcement feeds. Designed to help downstream agents reconsider postponed human goals after technology changes. No personal conversations, health data, user IDs, or credentials are collected.

### What buyers get

A structured Dataset item for each recent potentially actionable official announcement:

- `signal_id`, `event_type`, `vendor`, `title`, `categories`, `published_at`
- `evidence_url`, `source_id`, `source_feed_url`, `source_type`
- `availability: "not_verified"`, `review_required: true`, `prompt_hint`

The Actor **never** claims a feature is generally available. An official headline is evidence of an announcement, not evidence of access for a particular region, plan, or account. Customers should verify at the linked original page before notifying a person. A successful response is one Dataset report item whose `signals` array contains all returned candidates. If none of the articles match, the dataset is empty and the `SUMMARY` key records source health and counts. Missing sources are **not** interpreted as zero new announcements.

### Sources

Allowed, hardcoded public RSS/Atom endpoints only (no arbitrary URL input):

- OpenAI official news
- Google AI official blog
- Claude Platform official release-notes RSS feed

News may be mixed with product announcements. This early version uses deterministic *headline-only* keyword classification to find candidates. It does not make inferred capability claims. An unavailable source is logged under `SUMMARY.failed_sources`, and total failure fails the run. No article body is collected or resold.

### Run locally

Requires Node 22+ and network access for actual feed collection.

```bash
npm install
npm test
npx apify-cli run
```

Or deploy this directory to a **new private Actor** in Apify, set input using `examples/INPUT.json`, run privately, inspect Dataset and `SUMMARY`, then review costs/terms before considering publication. Keep it separate from existing law and Kobe permit Actors. The Actor fetches official feeds on every request, so buyers receive on-demand fresh results without a paid background schedule. Code requests the one-time `report-delivered` PPE event once for a successful nonempty report; configure it at $0.05 before monetization.

### Implementation and safety limits

- Headlines can be wrong or misleading; no automated personal advice or psychological assessment.
- For goal matching, let a buyer's own AI compare **categories only** with user-approved, on-device or private context. Do not transmit personal histories into this Actor.
- Do not proactively message a person without consent or circumvent their notification preferences.
- AI agent should consider timing and human autonomy, not always advocate action.
- Cost, licensing, acceptance criteria, public listing, event-based pricing and Apify account verification must be evaluated independently before launching.
- v0.1 is a *recent announcements feed*, not a persistent delta engine. A future separate updater and query Actor should be introduced if reliable first-seen timestamps and daily archival become necessary.

### Build status

Local parser/classifier tests can run offline; live Apify Build/Run and official source fetches require external runtime access. Existing repositories and services remain untouched.

### Store-readiness status (2026-11-02)

- \[x] README, input/output schemas and default Dataset field metadata packaged for private Build.
- \[x] Offline classification/parser tests run locally.
- \[ ] **Live source fetch and Apify Build/Run not verified.** The source endpoints may have changed.
- \[ ] Product claims, source terms, and usage costs require live review.
- \[ ] Listing, pricing model/event, permissions, monetization, KYC and publication remain unset.
- \[ ] No scheduler or auto-renew is configured.

**Do not call this a production-ready or publicly saleable Actor until all unchecked items pass.**

### Monetization contract (must be verified in Apify Console)

- One one-time chargeable event named `report-delivered` for a successful **nonempty** report. All signals are delivered atomically inside that single report item. No charge for empty results or total source failure.
- Approved initial price: **$0.05/report**, subject to private paid validation before publication.
- Select **Pay per event** and **do not charge platform usage separately** for per-request agentic payment eligibility. Set limited permissions and disable Standby. Complete KYC.
- The Actor uses Apify's PPE-aware Dataset write so successful output delivery and one custom event are handled together, then confirms the authoritative per-run event count.
- Local and non-monetized runs do not prove that live PPE charging or end-user budget limits work. Include paid sandbox validation before publication.

### Data minimization and terms

- Do not input private memories, user histories, credentials, health data or IDs. Parameters specify only public-source filters.
- Headlines and links are from selected official public sources; this Actor only aggregates public metadata, not entire copyrighted article bodies. Confirm source terms, robots access and licensing before paid distribution.
- Source titles, dates and availability may be inaccurate; report includes `failed_sources` and a `status` to prevent interpreting unavailable sources as zero news.
- Buyer is responsible for deciding whether to send the user a suggestion; do not infer medical, psychological or financial circumstances from these signals.

### Release gates

1. Private Apify Build + private Run, verify feeds that still serve XML and 0/partial/all-source-error behavior.
2. Verify output schema and feed data against 10–30 real announcement examples. Check sample freshness and duplicate URLs.
3. Measure memory/CPU/network usage and per-run cost. Configure `report-delivered` event and a price with positive margin.
4. Test billing and caller max-charge limit with PPE enabled, without exposing personal data.
5. Confirm source access and republication terms, store description, KYC and payout settings.
6. Obtain owner approval before any public visibility, paid charge or recurring schedule.

### What's new in v0.4 — incremental agent use

Pass the previous report's public `signal_id` values as `excludeSignalIds` (max 500) to get only unseen announcements. This is an **opt-in client-managed cursor**, not a service-side database. No user profile, private memory, or behavioral data is accepted. The output remains a list of headline **candidates**, not confirmed product eligibility or a forecast.

The Actor now validates all accepted input keys and values at runtime, as well as through its Apify input schema. Unknown keys (including memory content) are rejected without logging raw values. Malformed payment charge receipts never permit report delivery. When filtering removes all candidates, there is no event charge.

### Offline integration checks

`node --test` includes a full business-flow simulation with fake official RSS/Atom feed responses, payer approval or rejection, duplicate suppression, and error/summary handling. It uses no real Apify account or token and cannot replace a private Apify Build+Run.

# Actor input Schema

## `recentDays` (type: `integer`):

Only announcements in this many past days.

## `maxItems` (type: `integer`):

Maximum number of unique capability announcement candidates to return.

## `language` (type: `string`):

Language for cautious prompt hints and notices. Official titles remain unchanged.

## `vendors` (type: `array`):

Optional; empty/missing means all. Allowed values: openai, google, anthropic. Other values are rejected at runtime.

## `categories` (type: `array`):

Optional; empty/missing means all. Allowed values: video_creation, audio_voice, image_creation, agent_automation, coding, memory, integrations, research. Other values are rejected at runtime.

## `excludeSignalIds` (type: `array`):

Optional: send 20-character hexadecimal IDs from a previous report to receive only unseen candidates. Invalid IDs are rejected at runtime. Do NOT include private conversation data or user identifiers.

## Actor input object example

```json
{
  "recentDays": 30,
  "maxItems": 30,
  "language": "en"
}
```

# Actor output Schema

## `signals` (type: `string`):

One JSON report item containing a signals array. Empty Dataset is valid when feed sources succeed but there are no matching announcements.

## `summary` (type: `string`):

Summary of fetched and failed sources; check for partial runs.

# 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("jp-public-data/ai-capability-unlock-feed").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("jp-public-data/ai-capability-unlock-feed").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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 jp-public-data/ai-capability-unlock-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jp-public-data/ai-capability-unlock-feed"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/NDsqSdh5QDf21hrEZ/builds/Smd5A06BbVRco4E9z/openapi.json