Agent Skills

Skills teach your coding agent how to use Emergent Mind: how to survey a field, how to find an open research problem worth attempting, and how to publish a verified finding back to the site. They work in Claude Code, Codex, Cursor, and the other agents that support the Agent Skills standard.

Reading the API is included on every plan, including the free one, so you can install these and try them today.

Skills Overview

emergent-mind-papers

Updated August 21, 2026

  • See what is trending in any arXiv category
  • Search by idea rather than by keyword
  • Pull authors, abstracts, and citation counts
  • Find implementations, related work, and open problems
Read the skill

emergent-mind-open-problems

Updated August 21, 2026

  • Find unsolved problems extracted from papers
  • Judge which ones a computation could settle
  • Read what others have already established
  • Publish findings to the problem's page
Read the skill

Setup

  1. 1. Create an account

    Sign in and we will have an API key waiting on this page, so there is nothing to go and fetch. Every plan includes 50 API requests a month, and paid plans include 2,500 or 10,000.

    Create an account
    Log in

  2. 2. Install the skills and set your key

    One paste to Claude Code, Codex, Cursor, or any other agent that can fetch URLs: it writes both skills to your skills directory and sets the EMERGENT_MIND_API_KEY environment variable, which is where the skills read your key from.

    Ask your agent
    Install the Emergent Mind agent skills. Fetch each of these URLs and save it as a SKILL.md in its own folder under your skills directory, named after the skill's `name` field: https://www.emergentmind.com/skills/papers https://www.emergentmind.com/skills/open-problems Then set EMERGENT_MIND_API_KEY to the key from my Emergent Mind account so that future sessions have it, choosing a location that non-interactive tool shells will read, and export it in the shell you are in now. After setting the key, generate an overview of these skills.

    Sign in above and this prompt will carry your actual key.

  3. 3. Ask for something

    Paste one of the recipes below into your agent. The skills are model-invocable, so your agent will also reach for them on its own when a task calls for research papers or open problems.

Recipes

The recipes below are eleven prompts, meant to be run in order the first time through. Paste each one into an agent that has the skills installed, and by the last you will have used every part of both skills. Most of them do not mention Emergent Mind on purpose: the skills are model-invocable, so describing the task should be enough for your agent to reach for them. If your agent goes somewhere else instead, add "using Emergent Mind" to the prompt and it will.

Paper info

Everything Emergent Mind holds on one paper: its abstract, related work, implementations, and the open problems the paper raises.

5. Go deep on one paper

Works from an arXiv id, an arxiv.org link, or an emergentmind.com link, so there is no need to search for a paper you can already name.

Prompt
Look up arXiv 2603.27467. Summarize what it does, what it is built on, and what it leaves unresolved. Then tell me what to read next from its related work, and whether it raises open problems a computation could make progress on.

6. Find working code

Papers carry the repositories that implement them, ordered with repositories first and by stars, so "is there code for this" is one lookup rather than a hunt through GitHub.

Prompt
Find recent papers on retrieval-augmented generation that have working implementations. For the most promising one, tell me what the repository does, how many stars it has, and whether it looks maintained.

7. Ground a decision in the literature

Read several papers at once and get an answer rather than a reading list, including where the evidence is thin.

Prompt
I am choosing between speculative decoding and quantization to cut our inference costs. Find the work on each published since June 2026, read the abstracts, and tell me what the evidence actually supports and where it is thin.

Open problems

Unresolved questions extracted from papers, each with a public page where anyone can publish a verified finding. A finding does not have to be a solution: numerical evidence, a bound checked for small cases, a counterexample, a corrected statement, or an honest negative result all count. The three steps run in order in one conversation, so each pastes in as it is. If more than one problem looks worth attempting, ask the agent to spawn a session per problem: the work needs sustained attention, and one problem per session keeps each attempt focused.

8. Find candidates worth attempting

Surveying is cheap and researching is not, so judge ten from their statements before committing to any. Expect one or two to be worth it, and search again rather than settling.

Prompt
Find the 10 most recently referenced open problems in combinatorics. Judge which ones look tractable from their statements, and tell me the one or two a computation could actually settle and why.

9. Work it

Reading comes first for a reason. The references give the problem in the authors' own words and usually pin down the exact quantity in question, and an existing finding is either a duplicate to avoid or a foundation to build on. Most attempts should end here with nothing to publish, which is the expected outcome rather than a failure.

Prompt
Work on the most promising one. Read its full statement, the papers that reference it, and any findings already published before you start. Then attempt it, verifying every substantive claim at least two independent ways, such as brute force against a formula or two separate implementations, and keep the reproduction code. If the evidence does not hold up, tell me that and stop.

Models give up on research problems early, and often call one intractable after trying a single angle. When that happens, push back rather than accepting it: naming concrete directions turns encouragement into something the agent can act on.

If it stalls
That is a reasonable first attempt, but do not stop there. Try a different angle: compute more cases and look for a pattern in the small ones, test the claim against a family of likely counterexamples, or check whether a weaker version holds. Take your time. If you still cannot make progress after that, tell me what you ruled out and what you would need to go further.

10. Publish the finding

Publishing is what makes the attempt worth more than the hour you spent on it. It saves the next person from redoing what you ruled out, gives whoever picks the problem up something to build on, and puts your name on a public page next to the problem. Partial progress is worth posting, and so is a negative result that was expensive to establish. Findings appear immediately with no review step, which is why the verification above matters. Nothing here is one-way: ask the agent later and it can correct a finding you have published or delete it outright, on any plan, however long ago you posted it.

Prompt
Publish it to the problem's page: a one or two sentence summary of the result, the full writeup with method and verification evidence, and the reproduction code. Show me the text and ask me what name to publish it under before you submit anything.

11. Draw a problem at random

No topic in mind, or you would rather not take whatever ranks highest. Drawing several and picking beats drawing one and accepting it.

Prompt
Draw five random open problems in combinatorics. Tell me which one looks most tractable for a computational attack and why, and whether anyone has published findings on it yet.

Under the hood

The skills are generated from the same constants the API enforces, so the limits and defaults they document cannot drift from the running code. Installing copies them to your machine, where they stay as they were until you update them, so each skill carries the date it was published and tells your agent to ask you about refetching once it is more than a month old or the API starts contradicting it. Agents that discover skills by domain read the skills index; everything the skills describe is documented endpoint by endpoint in the API reference.