Omega Point for agents

Omega Point takes one research goal and produces the questions that science still leaves open, competing hypotheses for each, and the experiments that would decide between them. The engine runs on our server. Your agent, from Claude Code, Codex, Cursor, a web chat with an MCP connector or a plain script, starts a run, follows it and brings you the published result. To link the agent to your Eternal Search account you open one link it sends you and press Connect; the agent itself never signs in anywhere.

Two versions of the engine

Omega Point has two versions. Tell your agent which one to run; it asks you before the first run when you have not said.

	Omega Point 1.5	Omega Point 2.00
How it runs	On our server. Your agent starts the run, follows its progress and hands you the result. This page describes this version.	On our server. Your agent starts the study, passes on its clarifying questions and your answers, and reads the result.
Account	Optional. A run linked to your account can be continued from any session.	Required. The agent sends you one link; you open it and press Connect.
Result	Open questions and competing hypotheses, each published on its own page.	One card for each significant gap in what is known: competing variants from the obvious to the radical, each with a causal chain, evidence quoted from open full-text papers and a first experiment. Cards are published after review by our team.
At a time	Up to three runs per person at a time; when the server is busy the run waits in a queue and starts by itself.	Up to three studies per person at a time; the next one waits for a free slot.

Starting Omega Point 2

Say to your agent: start an Omega Point 2 study on my question, followed by the question in your own words. Over MCP it calls omega2_start_study, then omega2_study_status; it asks you every clarifying question from omega2_list_clarifications and sends your answer with omega2_answer_clarification; at the end it reads omega2_cards, omega2_card and omega2_export. With the connector script:

node omega-connector.mjs register --provider codex        # once; any provider, 2.00 does not use it
node omega-connector.mjs login                            # required for 2.00: it prints a link; you open it and press Connect
node omega-connector.mjs study-start "which mechanisms limit muscle regeneration after 60"
node omega-connector.mjs study-status <study>             # progress and the next action
node omega-connector.mjs study-questions <study>          # clarifying questions waiting for you
node omega-connector.mjs study-answer <study> <question_id> --file answer.txt
node omega-connector.mjs study-cards <study>              # the cards, each in full
node omega-connector.mjs study-export <study> --markdown  # the whole study as one file

Over plain HTTP: POST https://eternalsearch.net/api/v1/omega2/studies with {"question": "..."} and Authorization: Bearer <token>; then GET /api/v1/omega2/studies/<study>, /clarifications, POST /clarifications/answer, /cards and /export. Your studies are listed on My runs; published cards appear in the Omega Point catalogue.

Omega Point 1 on your own model

The first engine runs without our server too: your agent downloads the omega-point-1-local skill and decomposes your research goal into questions, gaps, hypotheses and experiments on your own model. Results stay with you and are not published here. Download: https://eternalsearch.net/api/v1/omega1/skill (add ?include=content for every file), or the omega_get_local_skill MCP tool. Save the files under ~/.claude/skills/omega-point-1-local/ or ~/.codex/skills/omega-point-1-local/ and say: run an Omega Point 1 study locally on my research goal.

Omega Point 2 on your own model

The same engine also runs without our server and without an account: your agent downloads the omega-point-2-local skill (the whole engine logic as instructions) and runs the study on your own model and free scientific sources. Results stay with you and are not published here. It needs an agent with files, a shell and subagents, such as Claude Code or OpenAI Codex. Download: https://eternalsearch.net/api/v1/omega2/skill (add ?include=content for every file in one response), or the omega2_get_skill MCP tool. Save the files under ~/.claude/skills/omega-point-2-local/ or ~/.codex/skills/omega-point-2-local/ and say: run an Omega Point 2 study locally on my question.

How a run works

Register and link

One call returns a token, shown once. To link the agent to your account it sends you one link; you open it in your own browser and press Connect. The agent never signs in anywhere. A linked agent stays yours: a lost token is replaced and its runs continue.

Start a run

Send your question in your own words. Every run is a full run of several hundred model calls; you choose Russian versions and poster sheets.

Follow the run

The run executes on our server and takes hours; it keeps going while no session is open. Your agent reads its status and tells you where it is before every turn ends, and asks you to resume it if it stops.

Read the published result

Every open question and hypothesis gets its page on the site, in English and Russian, and the agent saves them as markdown files. Your runs are listed on My runs.

Three ways to connect

The connector script

One Node 20 file, no dependencies. It registers a link, starts runs, follows them and fetches the results.

curl -sO https://eternalsearch.net/omega-point/api/agent/v1/skill/scripts/omega-connector.mjs
node omega-connector.mjs register --provider codex        # once; any provider
node omega-connector.mjs login                            # optional: link the agent to your account
node omega-connector.mjs run "restore youthful skin properties in middle-aged adults"
node omega-connector.mjs progress <run_key>               # where the run is, written for you
node omega-connector.mjs serve --run <run_key> --detach   # watches the run in the background until it is done
node omega-connector.mjs outcome <run_key>                # links to every published question and hypothesis
node omega-connector.mjs documents <run_key>              # the same as markdown files

Remote MCP server

The same operations as tools of the Model Context Protocol (MCP), so an agent can start and follow a run with no script at all.

claude mcp add --transport http omega-point https://eternalsearch.net/api/mcp/omega-agent \
  --header "Authorization: Bearer <token>"

Tools: omega_register, omega_login_start, omega_login_poll, omega_account_runs, omega_set_concurrency, omega_start_run, omega_pull_task, omega_complete_task, omega_release_task, omega_run_checkpoint, omega_continue_run, omega_run_status, omega_list_runs, omega_run_result, omega_run_outcome, omega_run_documents, omega_run_document, omega_submit_feedback, omega_list_feedback, omega_stop_run, omega_resume_run, and for Omega Point 2 the omega2_* tools in the section above.

The skill package for agent harnesses: https://eternalsearch.net/omega-point/api/agent/v1/skill (SKILL.md).

Results of any run

The questions and hypotheses a run has published are public. Any agent can fetch them with the run key alone, whoever started the run: you, another user or the Eternal Search site. Reading needs no link, no token and no registration. The connector saves one markdown file per published question and per hypothesis, in each language, with the text and structure of its page on the site, together with an index for each language and the poster sheets. Every hypothesis file ends with its assessment: eight criteria rated from 0 to 10, each with its reason, and the scientific literature behind them.

node omega-connector.mjs documents <run_key>          # the folder omega-<run_key>/
node omega-connector.mjs outcome <run_key> --texts    # links, text sizes and the full texts

Directly over the API: GET https://eternalsearch.net/omega-point/api/agent/v1/runs/<run_key>/documents lists the files, and GET https://eternalsearch.net/omega-point/api/agent/v1/runs/<run_key>/documents/file?name=<name> returns each one. Over MCP the tools are omega_run_documents, omega_run_document and omega_run_outcome. Your agent can then turn the files into any format you ask for.

What to expect

A run takes hours. A full run is several hundred model calls on our server. Step 7 writes each hypothesis in reviewed stages (a check of the scientific foundations, generation from the complete archived abstracts, a causal map, a review, a revision, a verification and a clarity loop with a reader edition): up to 36 calls for each of at most 10 open questions. The run keeps going while no session of yours is open.
Up to three runs per person at a time. A fourth run of yours waits for one of the first three to finish. When the server is busy the run waits in a queue (queued_for_slot) and starts by itself; the status says its position.
The run continues after the engine. The engine reasons to the hypotheses of step 7, then the server names each hypothesis, removes duplicates, writes the explanations and question headings, translates and writes the Russian report. The engine's own status turns to completed_at_step at that point, and the run is only half way: relay_phase is engine, then finishing, then done; GET /runs/{key}/result answers 202 until then.
Your agent keeps you informed. A run takes hours, and you see only what your agent writes. Every run status carries progress_report, a short report written for you: the phase and step, what each finishing stage still has to do, the time since the start and what comes next. The skill obliges the agent to pass it on in your language before every turn of its ends.
Your agent checks that its skill is current. A skill attached to a chat once stays a copy, while the skill on the server keeps improving. GET /skill/version publishes the current revision and the sha256 of every skill file. Before a run, a resume and a new session the agent compares its copy (node omega-connector.mjs check-skill), downloads the current files when they differ (update), reads the new instructions and tells you. Every pull and every status carries skill_revision, so a change during a run is noticed too. A run already in progress continues under the same key after an update.
Russian versions are your choice. Translations, Russian question headings, the Russian report and the Russian poster sheet. The agent asks you before starting and passes translate_ru: false to skip them; by default they are on.
Poster sheets are your choice. One sheet per hypothesis, English and Russian, drawn by our image generation. The agent asks the user before starting and passes posters: true to make them; by default they are off.
Your feedback is stored with the run. When the run is done, the agent asks you what is wrong, what is missing and what is worth improving, then posts your remarks and the corrections or improvements it proposes to POST /runs/{key}/feedback. The Eternal Search operator reads them on the runs desk; changes are made by the operator, never applied automatically. Feedback on a stopped or failed run is welcome too.
A 502 or a reset connection means the server is restarting. New code ships several times a day and the relay is down for a few seconds each time. The connector and the MCP server wait this out by themselves. If you call the API directly, wait 15 seconds and repeat the same call. The link, the run and a pulled task survive the restart.
Link the agent to keep your token. The token of a link is shown once. Link the agent to your Eternal Search account (node omega-connector.mjs login prints a link; you open it and press Connect): if the token is lost, the same command gives the agent a new token for the same link (choose it under "Other options" on the page), and every run continues under its key. Your runs are listed on My runs.

Relay mode

The server can also hand the model calls of a run to your agent instead of answering them itself. That mode is not active at present; the start response and the run status say which one applies (run_mode: server or agent_relay). In relay mode every prompt of the engine comes to your agent as a task with a tier (high, mid or low) and your model writes the answer, most often one JSON object; the run goes as fast as your agent answers, in parallel up to the width you declare (concurrency, 1 to 256); it stops after every stage and waits for you to say continue, and it waits for your agent when nobody pulls (24 hours, then it stops and can be resumed). The connector serves such runs with serve --run, and a harness without a login answers each task itself with register --provider subagent, next --max 4 and answer <task_id> --file answer.txt. The skill package describes it in full.

What stays on our server

Literature search in PubMed, OpenAlex and Semantic Scholar, embedding-based deduplication, validation, state and storage, and the model calls of every run the server executes. Every run is stored and, when it finishes, published on the site.

The protocol

Base URL https://eternalsearch.net/omega-point/api/agent/v1. JSON in and out. Every call except registration, login and reading published results sends Authorization: Bearer <token>. Full specification: openapi.json.

Call	Purpose
POST /links	Register a link: agent kind, provider label, tier map, concurrency. Returns the token once.
POST /links/login, /links/login/poll	Link the agent to your site account: the agent sends you `verification_url`, you open it and press Connect; the poll (with `wait_s` up to 25) returns the token of a new link, or a new token for one of your links.
GET /account/runs	Every run of every agent linked to your account.
PATCH /links/current	Relay mode: change how many tasks you answer at once (1 to 256).
GET /parallelism	Which units of a run are independent, where a stage waits for the one before, and the priority lanes. No token needed.
POST /runs	Start a full run: goal, optional lens, `translate_ru` for the Russian versions, `posters` for the poster sheets. Answers `run_mode` (server or agent_relay) and, when the server is busy, `queued_position`. Up to three runs per person at a time.
POST /tasks/pull	Relay mode: long poll up to 25 seconds for tasks: tier, messages, response format, temperature, token limit, timeout; `reports_for_user` when a progress report is due.
POST /tasks/{id}/complete	Relay mode: post the answer with the model name and usage, or an error.
POST /tasks/{id}/release	Relay mode: give a pulled task back untouched.
GET /runs/{key}	Status, current step, `run_mode`, `relay_phase`, `keep_serving`, `finishing_pending`, `next_action` and `progress_report` (the report for you), task counters, waiting since, queue depth, agent presence.
GET /runs/{key}/checkpoint, POST /runs/{key}/continue	Relay mode: the stage result the run waits at (an overview for the chat and the complete result for a file); continue the run when you say so.
GET /runs/{key}/outcome, /documents	What the run published: links and text sizes, or the folder of markdown files. Open to anyone with the run key.
GET /runs/{key}/result	The full result once `relay_phase` is `done`; 202 while the run still owes calls (`?engine_only=true` reads the engine result early); the saved steps of a stopped run.
POST /runs/{key}/stop, /resume	Stop a run (on a run whose engine is done: end the finishing phase); continue a stopped or interrupted run from its saved steps, under the same run key, as many times as needed.
POST /runs/{key}/feedback, GET	Store the owner's feedback and the agent's proposals (author user or agent, kind feedback or proposal, optional target); list them with their disposition.

Run statuses: queued_for_slot, executing, awaiting_user_llm, completed, completed_at_step, interrupted_at_step, failed_at_execute, stopped_awaiting_user_llm. Phases: engine, finishing, done, stopped.