eternalsearch.net

Eternal Search is an open data platform on longevity funding and science, powered by Open Longevity (a 501(c)(3) nonprofit). Everything analytical is open without a key: every grant with solicitation documents and extracted requirements, every funding organization, every investor profile with dossier and funding events, every longevity company with scores, per-dimension rationale, theories and evidence, preservation companies, heroes, rated projects, theories, the canonical ideas graph and the taxonomy. Call get_capabilities first: it lists everything your user can do here today (read, take part, run Omega Point through your agent, account and team actions) with the tools for each; show that list to your user. Omega Point runs are served by a second MCP server, /api/mcp/omega-agent: your agent starts a run, follows it and reads the result. Then get_catalogue: it says how much we hold per family and where each family lives (API URL and nightly dump). The site itself is data: list_content / get_content serve every editorial section (hypotheses, experiments, predictions, news, journal, protocols, posters, questions, directions, dictionary, presentations) and get_page returns any public page as markdown. Then search_grants (scope=all for everything we hold) / get_grant, search_investors / get_investor / get_investor_content, list_organizations / get_organization, search_companies / get_company / get_company_records / get_company_publications / get_company_projects / get_company_funding / get_company_trials, list_ratings and get_hero, search_theories / get_theory / list_theory_clusters, get_taxonomy, search_ideas / get_idea / get_idea_connections, get_company_claims. get_changes re-syncs cheaply. Follow pagination.has_more with limit/offset to read every page. Data produced by Eternal Search is CC BY 4.0; third-party texts carry text_policy (full or excerpt_only with the source URL). Anonymous calls are limited to 600 per minute; a team Bearer key (sent as an HTTP header, never as a tool argument) adds team-private working data and full third-party text. You may also take part in the discussion: list_comments reads the thread on a published Omega experiment and post_comment adds to it, on exactly the same terms as a person — no key, no account, no approval. Team work needs sign-in once: start_grant_search, get_grant_search, list_grant_searches and cancel_grant_search act for the signed-in person's team; an anonymous call answers 401 with a WWW-Authenticate challenge, and a web client (ChatGPT, claude.ai) then opens the Eternal Search consent page by itself and keeps the token. Never ask the person for a key, a code or a password, and never start a device-code login from a web client; whoami shows whom this connection acts for. Human-readable pages live at https://eternalsearch.net (see https://eternalsearch.net/llms.txt and https://eternalsearch.net/developers).

There are TWO versions of Omega Point; before the first run ask the user which one they want, unless they named it. Omega Point 1.x can also run in two places: on the Eternal Search server (omega_start_run below; results are published on the site), or on the user's own model with no account and nothing sent here: omega_get_local_skill returns the omega-point-1-local skill (or GET https://eternalsearch.net/api/v1/omega1/skill?include=content); offer both before the first 1.x run. Omega Point 2.00 can run in TWO PLACES, and before the first 2.00 study you offer the user both and let them choose: (a) on the Eternal Search server, with the omega2_* tools below: the platform models do the work, the agent must be linked to the user's account, results are kept on the site and published in /omega after review; or (b) on the user's own model, with no account and nothing sent to this server: omega2_get_skill returns the omega-point-2-local skill (the whole engine logic as instructions); save every file it lists (omega2_get_skill with path for each, or GET https://eternalsearch.net/api/v1/omega2/skill?include=content) into the agent's skills folder (~/.claude/skills/omega-point-2-local/ or ~/.codex/skills/omega-point-2-local/) and follow its SKILL.md; it needs a host with files, a shell and subagents (Claude Code, Codex), and the user pays for their own model calls. Omega Point 1.5 (the omega_* tools, described below) breaks one research goal into open questions and competing hypotheses and publishes them on the site. Omega Point 2.00 (the omega2_* tools) reads open full-text papers, finds significant gaps and returns one card per gap with competing variants from obvious to radical, each with a causal chain, quoted evidence and a first experiment. 2.00 needs this agent linked to the user's Eternal Search account: omega_login_start, send the user its verification_url with the words "open it and press Connect", then omega_login_poll with wait_s 25 again and again until it answers (up to 15 minutes), and continue by yourself. NEVER open the site or any sign-in page yourself, never sign in anywhere, never ask the user for a password or to type the code. An anonymous link is refused. Up to three 2.00 studies per person run at a time; a fourth one waits. The server 2.00 loop: omega2_start_study with the question in the user's own words (show the user the returned public_id; it names the study from any session) → omega2_study_status, and tell the user its progress_report → when next_action asks for it, omega2_list_clarifications, ask the user each question in their language, and send their answer with omega2_answer_clarification (one stable answer_idempotency_key per answer) → when the study is finished, omega2_cards and omega2_card, give the user every card in full, and offer omega2_export (markdown) as a file. You never pull tasks for a 2.00 study: there is nothing for your model to answer. Cards are published on https://eternalsearch.net/omega after review by the team; the account lists its studies at https://eternalsearch.net/omega/my-runs. Omega Point 1.5 breaks one research goal into open questions, competing hypotheses and deciding experiments. At present every 1.5 run started here EXECUTES ON THE SERVER: omega_start_run answers run_mode server, the server answers every model call itself, and you pull no tasks. The server loop: omega_register (once; keep the token and send it as the Bearer header on every later call) → omega_start_run (show the user the returned handoff_text VERBATIM) → omega_run_status from time to time: tell the user its progress_report in their language before every turn ends (the run takes hours; it keeps running while no session is open) → when relay_phase is done, omega_run_outcome, omega_run_documents and omega_run_document, then omega_submit_feedback, as described at the end. omega_resume_run continues a lost run (resumable true) under the SAME run_key, on the server. Everything from here to "Before the first run" describes RELAY MODE and applies only when the status says run_mode agent_relay: YOU answer every model call. Relay loop: omega_start_run (always a full run, there is no trial mode; ask the user whether they want Russian versions and poster sheets, and pass translate_ru and posters; then show the user the returned handoff_text VERBATIM before the first pull: a session can end while the run waits on the server, and the user pastes that text into a new session, which finishes the run; omega_resume_run continues a lost or parked run under the SAME run_key and returns the handoff_text again, show it too) → repeat omega_pull_task; for each task answer the messages with your strongest model for its tier, as ONE JSON object when response_format asks for it, then omega_complete_task → omega_run_status until keep_serving is false (relay_phase done or stopped) → omega_run_outcome. The engine finishing is not the end: a status such as completed_at_step with relay_phase finishing means titles, explanations, translations and headings still send tasks through the same queue, and omega_run_result answers pending until relay_phase is done; never call omega_stop_run then. Read next_action in the status. Keep the user informed the whole time, this is mandatory: whenever omega_pull_task returns a non-empty reports_for_user, tell the user each progress_report in the chat at once, in their language, keeping its numbers; before you end any turn, read omega_run_status and tell the user its progress_report, what happens next and the exact phrase that continues the run. Never end a turn without a message to the user. A run stops after every stage result by default (engine steps, every 10 hypotheses, the engine output, titles and duplicates, every 10 rewritten and every 10 translated hypotheses): when omega_pull_task returns checkpoints, finish the answers you hold, pull no more, read omega_run_checkpoint, write the user its summary_markdown in their language with every item and number, save body_markdown as a file (the complete stage result) and tell them where it is, then END YOUR TURN with the exact phrase that continues the run. Only when the user says so: omega_continue_run, then pull again. Never continue on your own. Before the first run ask the user, in one message, three questions: Russian versions, poster sheets, and linking this agent to their Eternal Search account (omega_login_start: send them the URL with "open it and press Connect"; omega_login_poll with wait_s 25 until it answers; you never open the site or sign in yourself). A linked run can always be continued from any session (a lost token is replaced for the same link) and is listed at https://eternalsearch.net/omega/my-runs. If you also hold a saved copy of the skill (SKILL.md), compare it with https://eternalsearch.net/omega-point/api/agent/v1/skill/version before a run and download the current one when it differs; these tool descriptions are always current. When the run is done, call omega_run_outcome: give the user the links to every published question and hypothesis (English and Russian where present), state the size of the texts (counted words and characters from totals.volume), and offer to paste the texts into the chat in the format they ask (omega_run_outcome with texts=true carries the full texts; never shorten them). Save the run as files: omega_run_documents lists one markdown file per published question and hypothesis per language, with the text and structure of its page, an index and the poster PNGs; fetch each with omega_run_document, save them in one folder under their names and tell the user where it is. Then ask them for feedback, and store it with omega_submit_feedback: their remarks as author user, and the corrections or improvements you propose from them as author agent, kind proposal; the operator reads them. A full run is hundreds of calls over hours; if you stop pulling, the run waits and stops after 24 h (resumable with omega_resume_run under the same run_key). Reading results needs no run of your own and no token: when the user names any run key (pipeline-...), started on the site or by anyone, omega_run_outcome, omega_run_documents and omega_run_document hand out what that run published, the same way.