# Embodied AI & Robotics Papers Monitor (arXiv) (`simonzhong/embodied-ai-papers-monitor`) Actor

Track new arXiv papers on embodied AI and robot learning: VLA models, manipulation, humanoids, legged locomotion, sim-to-real, world models. Topic tags, code links, only new papers each run.

- **URL**: https://apify.com/simonzhong/embodied-ai-papers-monitor.md
- **Developed by:** [Simon Zhong](https://apify.com/simonzhong) (community)
- **Categories:** AI, News, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 paper records

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

## Embodied AI & Robotics Papers Monitor (arXiv)

Get a clean, **topic-tagged**, **deduplicated** feed of new research papers on **robot learning and embodied AI**:
vision-language-action (VLA) models, robotic manipulation, dexterous hands, humanoids, legged locomotion,
sim-to-real, world models, navigation and more. Data comes straight from the **official arXiv API**.
Run it once for a literature snapshot, or schedule it daily or weekly to get **only the papers you haven't seen yet**.

### Why this Actor

Generic arXiv scrapers return whatever matches a search box. This one is pre-configured for the embodied-AI field:

- **All of arXiv Robotics (`cs.RO`)**, plus the embodied-AI papers that are filed under **AI, Computer Vision or
  Machine Learning** (`cs.AI`, `cs.CV`, `cs.LG`) — those are only included when their title or abstract matches
  embodied-AI keywords (robot, embodied, VLA, humanoid, dexterous, sim-to-real, imitation learning, …), so you
  don't drown in general ML papers.
- **Focused on embodied AI by default**: every paper gets topic tags (VLA, Manipulation, Humanoid, Legged locomotion,
  Dexterous hands, Navigation, Imitation / robot learning, World models, Sim-to-real, Tactile sensing, …), and by default
  only papers with an embodied-AI tag are output. Classical robotics (drones, autonomous driving, SLAM, planning &
  control) is filtered out — clear **Only these topics** to get every robotics paper.
- **Code links**: GitHub / GitLab / Hugging Face links found in the abstract or comments, plus a `has_code` flag.
- **Monitoring mode**: scheduled runs output (and bill) only papers you haven't received before.

### Use cases

- **Robotics and embodied-AI teams**: a weekly digest of new VLA, manipulation or humanoid papers.
- **Researchers and students**: keep up with a fast-moving field without reading the whole cs.RO listing.
- **Investors and analysts**: track research activity in humanoids, robot foundation models and world models.
- **AI / RAG pipelines**: clean title + abstract + metadata records, ready to embed or feed to an LLM.
- **Alerts**: schedule the Actor and connect it to Slack, email, Google Sheets or webhooks with Apify integrations.

### How to use

1. Click **Start** with the defaults to get the last 7 days of embodied-AI papers.
2. Optional: narrow **Only these topics** (e.g. just `VLA` and `Humanoid`), clear it to get all robotics papers,
   or tick **Only papers with a code link**.
3. Results appear in the **Output** tab and can be downloaded as JSON, CSV, Excel or via API.
4. For monitoring, tick **Only output papers not seen in previous runs** and add a **Schedule** (e.g. daily).

### Input

| Field | Default | Description |
|---|---|---|
| `categories` | `["cs.RO"]` | Core arXiv categories: every paper is included |
| `extraCategories` | `["cs.AI","cs.CV","cs.LG"]` | Papers from these categories are included only if they match `extraKeywords` |
| `extraKeywords` | robot, embodied, VLA, humanoid, dexterous, sim-to-real, … | Embodied-AI phrases (title/abstract, any of them) for the extra categories |
| `primaryCategoryOnly` | `true` | Keep only papers whose *main* category is one of the above. Filtered papers are free |
| `topicFilter` | embodied-AI topics (VLA, Embodied agents, Manipulation, Dexterous hands, Humanoid, Legged locomotion, Navigation, Imitation learning, Robot learning, Diffusion / flow policies, World models, Sim-to-real, Tactile sensing) | Output only papers with at least one of these topic tags. Empty = all papers. Filtered papers are free |
| `onlyWithCode` | `false` | Output only papers with a GitHub/GitLab/Hugging Face link. Filtered papers are free |
| `keywords` | `[]` | Optional phrases that **every** paper must match |
| `keywordsOperator` / `keywordFields` | `OR` / `title_abstract` | Logic and fields for `keywords` |
| `lastNDays` | `7` | Date window; ignored if `dateFrom`/`dateTo` set; `0` = no date filter |
| `dateFrom` / `dateTo` | – | `YYYY-MM-DD` (UTC, inclusive) |
| `dateField` | `submittedDate` | or `lastUpdatedDate` |
| `maxRecords` | `100` | Max papers output (and charged) per run |
| `sortBy` / `sortOrder` | `submittedDate` / `descending` | also `lastUpdatedDate`, `relevance` |
| `onlyNew` | `false` | Skip papers seen in previous runs (free) |
| `includeNewVersions` | `false` | With `onlyNew`, output a paper again when a higher version appears |
| `seenStoreName` | `embodied-ai-papers-seen` | Named key-value store for seen IDs; use a different name per monitor |
| `maxScannedRecords` | `3000` | Cap on arXiv results scanned when client-side filters are on |
| `contactEmail` | – | Optional override of the contact in the User-Agent sent to arXiv |

Example: a daily monitor for VLA and humanoid papers that come with code.

```json
{
  "topicFilter": ["VLA", "Humanoid"],
  "onlyWithCode": true,
  "lastNDays": 3,
  "maxRecords": 200,
  "onlyNew": true,
  "seenStoreName": "vla-humanoid-monitor"
}
```

### Output example

```json
{
  "source": "arxiv",
  "arxiv_id": "2610.12345",
  "version": 1,
  "title": "Smooth Action Chunking Via Movement-Primitive Representations for Imitation Learning",
  "authors": [{"name": "…", "affiliations": []}],
  "abstract": "…",
  "categories": ["cs.LG", "cs.RO"],
  "primary_category": "cs.LG",
  "published": "2026-10-28T17:59:59Z",
  "updated": "2026-10-28T17:59:59Z",
  "pdf_url": "https://arxiv.org/pdf/2610.12345v1",
  "abs_url": "https://arxiv.org/abs/2610.12345v1",
  "doi": null,
  "journal_ref": null,
  "comments": "Project page: https://…",
  "topics": ["VLA", "Manipulation", "Imitation learning"],
  "code_urls": ["https://github.com/…"],
  "project_urls": ["https://…"],
  "has_code": true,
  "is_new": true
}
```

Topic tags are assigned by transparent keyword rules on the title and abstract (no AI model), so they are fast and
predictable but not perfect: a paper can have several tags or none. Each run also saves a `RUN_SUMMARY` record
(output / scanned / filtered / skipped counts, stop reason, the exact arXiv query) to its default key-value store.

### Pricing

**$2 per 1,000 papers** ($0.002 per output paper, event `paper-record`).
Papers skipped as already seen, or removed by the category, topic or code filters, are **free**. The run stops
cleanly at your maximum charge limit, so you never pay more than you set. Example: the default 7-day window has
roughly 230 embodied-AI papers (default `maxRecords` is 100, i.e. $0.20 per run; about $0.47 for all of them); a daily
monitor with `onlyNew` typically outputs 30–50 new papers (about $0.08).

### Tips

- arXiv announces new submissions with a delay (typically ~1 business day, none on weekends), so the most recent
  day of a window is usually still empty. For daily schedules use `lastNDays` ≥ 3 with `onlyNew` on. The overlap
  costs nothing because already-seen papers are not charged.
- Typical volume (checked Nov 2026, 7 days): ~233 papers with the default topic filter (197 with primary category
  `cs.RO`, 36 from `cs.CV`, `cs.AI` and `cs.LG`); ~324 with the topic filter cleared.
- Want everything in robotics, including drones, driving and SLAM? Clear **Only these topics**.
- Each arXiv page (≤100 papers) takes ≥3 s because of the rate limit, so 1,000 papers take about 30 s or more.
- Abstracts may contain LaTeX (`$...$`); it is passed through unchanged.

### FAQ

**Is this allowed?** Yes. The Actor uses arXiv's official, public API within its published rate limits and only
collects public metadata (titles, abstracts, authors, links). It does not download PDFs.

**Why are some general ML papers included?** Papers from `cs.AI`, `cs.CV` and `cs.LG` are included when they mention
robots or embodied-AI terms and get an embodied-AI topic tag. Remove a word from **Embodied-AI keywords**, or select
fewer topics, to make the feed stricter.

**Why is a robotics paper missing?** By default only papers with an embodied-AI topic tag are output. Clear
**Only these topics** to get every paper.

**Can I run several monitors?** Yes. Give each one its own `seenStoreName` so their "seen" lists don't mix.

### Data & attribution

Metadata is retrieved from the arXiv API. Thank you to arXiv for use of its open access interoperability.
Paper content remains under each paper's own license; this Actor does not download or redistribute PDFs.

# Actor input Schema

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

Every new paper in these arXiv categories is included (no keyword needed). Default cs.RO = Robotics. Leave empty to rely only on the keyword-gated categories below.

## `extraCategories` (type: `array`):

Papers from these categories are included only if their title or abstract matches one of the embodied-AI keywords below. Default: cs.AI, cs.CV, cs.LG (where many VLA, world-model and robot-learning papers are filed). Other useful ones: cs.CL, cs.MA, eess.SY.

## `extraKeywords` (type: `array`):

Phrases matched in title/abstract (any of them). Applied only to the extra categories above, not to the core categories. If empty, extra categories behave like core categories (all papers).

## `primaryCategoryOnly` (type: `boolean`):

Keep only papers whose primary (main) arXiv category is one of the core or extra categories. Recommended: drops papers from unrelated fields that are only cross-listed (e.g. a physics paper cross-listed to cs.RO). Filtered papers are not output, not charged and not remembered as seen.

## `topicFilter` (type: `array`):

Every paper gets rule-based topic tags. Only papers tagged with at least one selected topic are output. The default selection is the embodied-AI topics (VLA, manipulation, humanoids, legged locomotion, dexterous hands, navigation, imitation/robot learning, world models, sim-to-real, tactile…); classical robotics topics such as drones, autonomous driving, SLAM and planning & control are not selected. Clear the list to get every robotics paper. Filtered papers are free.

## `onlyWithCode` (type: `boolean`):

Output only papers whose abstract or comments link to GitHub, GitLab, Hugging Face or similar. Filtered papers are free.

## `keywords` (type: `array`):

Optional phrases that every paper must match (title/abstract by default), e.g. "humanoid", "diffusion policy", "tactile". Combined with Keyword logic below. Leave empty to get everything.

## `keywordsOperator` (type: `string`):

How the optional extra keywords above are combined. They are always AND-ed with the category clause.

## `keywordFields` (type: `string`):

Where keywords are matched: title + abstract (recommended), title only, or all fields (also authors, comments, journal ref).

## `lastNDays` (type: `integer`):

Only papers in the last N days (UTC). Ignored if Date from / Date to is set. 0 = no date filter.

## `dateFrom` (type: `string`):

Optional explicit window start (UTC, inclusive). Overrides Last N days.

## `dateTo` (type: `string`):

Optional explicit window end (UTC, inclusive). Defaults to now.

## `dateField` (type: `string`):

Which date the window applies to: first submission (recommended for new-paper monitoring) or last update.

## `maxRecords` (type: `integer`):

Maximum number of papers to output in this run. Each output paper is one paper-record event ($0.002, i.e. $2 per 1,000). Papers skipped as already seen are free.

## `sortBy` (type: `string`):

Sort order of arXiv results. Use submittedDate for monitoring; relevance is useful for one-off keyword searches.

## `sortOrder` (type: `string`):

Descending returns the newest first.

## `onlyNew` (type: `boolean`):

Monitoring mode: skip papers already stored in the 'seen IDs' key-value store. Skipped papers are not charged. Use with a schedule.

## `includeNewVersions` (type: `boolean`):

With 'Only new', re-output a paper when a higher version appears.

## `seenStoreName` (type: `string`):

Named key-value store that keeps seen arXiv IDs across runs. Use different names for independent monitors. Empty = do not persist.

## `maxScannedRecords` (type: `integer`):

When 'Only new', 'Primary category only' or a topic/code filter is on, upper bound of arXiv results scanned to find enough matching papers (each page of 100 takes ≥3 s due to arXiv rate limits).

## `contactEmail` (type: `string`):

Replaces the maintainer contact in the User-Agent sent to arXiv (arXiv asks API clients to identify themselves). Leave empty to use the default.

## Actor input object example

```json
{
  "categories": [
    "cs.RO"
  ],
  "extraCategories": [
    "cs.AI",
    "cs.CV",
    "cs.LG"
  ],
  "extraKeywords": [
    "embodied",
    "robot",
    "robotic",
    "robotics",
    "vision-language-action",
    "VLA",
    "humanoid",
    "legged locomotion",
    "quadruped",
    "manipulation policy",
    "robotic manipulation",
    "dexterous",
    "sim-to-real",
    "imitation learning",
    "visuomotor",
    "diffusion policy",
    "teleoperation"
  ],
  "primaryCategoryOnly": true,
  "topicFilter": [
    "VLA",
    "Embodied agents",
    "Manipulation",
    "Dexterous hands",
    "Humanoid",
    "Legged locomotion",
    "Navigation",
    "Imitation learning",
    "Robot learning",
    "Diffusion / flow policies",
    "World models",
    "Sim-to-real",
    "Tactile sensing"
  ],
  "onlyWithCode": false,
  "keywords": [],
  "keywordsOperator": "OR",
  "keywordFields": "title_abstract",
  "lastNDays": 7,
  "dateField": "submittedDate",
  "maxRecords": 100,
  "sortBy": "submittedDate",
  "sortOrder": "descending",
  "onlyNew": false,
  "includeNewVersions": false,
  "seenStoreName": "embodied-ai-papers-seen",
  "maxScannedRecords": 3000
}
```

# Actor output Schema

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

All paper records from this run (arXiv ID, title, topic tags, code links, authors, abstract, categories, dates, links).

## `runSummary` (type: `string`):

JSON summary of the run: counts of scanned, filtered (category / topic / code), skipped (already seen) and output records.

# 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 = {
    "categories": [
        "cs.RO"
    ],
    "extraCategories": [
        "cs.AI",
        "cs.CV",
        "cs.LG"
    ],
    "extraKeywords": [
        "embodied",
        "robot",
        "robotic",
        "robotics",
        "vision-language-action",
        "VLA",
        "humanoid",
        "legged locomotion",
        "quadruped",
        "manipulation policy",
        "robotic manipulation",
        "dexterous",
        "sim-to-real",
        "imitation learning",
        "visuomotor",
        "diffusion policy",
        "teleoperation"
    ],
    "topicFilter": [
        "VLA",
        "Embodied agents",
        "Manipulation",
        "Dexterous hands",
        "Humanoid",
        "Legged locomotion",
        "Navigation",
        "Imitation learning",
        "Robot learning",
        "Diffusion / flow policies",
        "World models",
        "Sim-to-real",
        "Tactile sensing"
    ],
    "keywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("simonzhong/embodied-ai-papers-monitor").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 = {
    "categories": ["cs.RO"],
    "extraCategories": [
        "cs.AI",
        "cs.CV",
        "cs.LG",
    ],
    "extraKeywords": [
        "embodied",
        "robot",
        "robotic",
        "robotics",
        "vision-language-action",
        "VLA",
        "humanoid",
        "legged locomotion",
        "quadruped",
        "manipulation policy",
        "robotic manipulation",
        "dexterous",
        "sim-to-real",
        "imitation learning",
        "visuomotor",
        "diffusion policy",
        "teleoperation",
    ],
    "topicFilter": [
        "VLA",
        "Embodied agents",
        "Manipulation",
        "Dexterous hands",
        "Humanoid",
        "Legged locomotion",
        "Navigation",
        "Imitation learning",
        "Robot learning",
        "Diffusion / flow policies",
        "World models",
        "Sim-to-real",
        "Tactile sensing",
    ],
    "keywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("simonzhong/embodied-ai-papers-monitor").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 '{
  "categories": [
    "cs.RO"
  ],
  "extraCategories": [
    "cs.AI",
    "cs.CV",
    "cs.LG"
  ],
  "extraKeywords": [
    "embodied",
    "robot",
    "robotic",
    "robotics",
    "vision-language-action",
    "VLA",
    "humanoid",
    "legged locomotion",
    "quadruped",
    "manipulation policy",
    "robotic manipulation",
    "dexterous",
    "sim-to-real",
    "imitation learning",
    "visuomotor",
    "diffusion policy",
    "teleoperation"
  ],
  "topicFilter": [
    "VLA",
    "Embodied agents",
    "Manipulation",
    "Dexterous hands",
    "Humanoid",
    "Legged locomotion",
    "Navigation",
    "Imitation learning",
    "Robot learning",
    "Diffusion / flow policies",
    "World models",
    "Sim-to-real",
    "Tactile sensing"
  ],
  "keywords": []
}' |
apify call simonzhong/embodied-ai-papers-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,simonzhong/embodied-ai-papers-monitor"
        }
    }
}
```

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/rIIChPnBLzsycT9du/builds/5DYFxlpW3QkkaIbcx/openapi.json