Automated discovery PRs

Set up from: Discover > Feed (create an interest from a repo) or the remyxai CLI | Runs in: your repo’s GitHub Actions

A scheduled action opening a draft PR that wires a paper into an existing call site

The success of an AI application depends on continuously adopting the right improvements. Identifying what to build next requires constant monitoring and evaluation of new ideas found in papers, repositories, models, benchmarks, and community discussions. Outrider automates that process by discovering new ideas, validating them against your codebase, and proposing actionable pull requests and issues—so your team can focus on building instead of scouting. On a schedule you set, Outrider:

Surfaces new work relevant to your repo from the sources Remyx indexes, ranked against what your team has actually shipped.
Validates fit against your real codebase — is there a call site, and is the change architecturally aligned (a refactor, a new technique, an upgrade)?
Drafts the most actionable candidate into a reviewable PR, wired into an existing module with code and tests.
Files an Issue instead for ideas worth watching that aren’t a clean fit yet, or that need input from the team or the source.

Outrider helps push development in the most fruitful directions without paying the upfront cost of finding and vetting each idea manually. Spend your time reviewing concrete proposals.

Human-reviewed by design. Outrider proposes changes as draft PRs and Issues, but every decision to merge remains with your team.

Quickstart

You’ll need to connect Remyx to your GitHub account via the Connectors view. The GitHub connector will install the Remyx GitHub App in your account or organization. Make sure to include access to your desired repo(s).Connecting Claude Code is required to draft implemented PRs (billed to your Anthropic account).For the CLI, also generate a Remyx API key.

Either path provisions the workflow and fires the first run. A draft PR or Issue lands in minutes.

From the CLI

pip install remyxai

# authenticate the CLI with your Remyx API key
export REMYXAI_API_KEY=<your-remyx-key>

# install Outrider on the repo and auto-create a Research Interest from it
remyxai outrider init --repo owner/name --auto-interest

--auto-interest creates a Research Interest from the repo; drop it and pass --interest <uuid> to use an existing one. If the GitHub App isn’t installed yet, the command prints the install link. No GitHub App? setup-local provisions with your own authenticated gh CLI instead; PRs then come from your account, not remyx-ai[bot]. (details)

remyxai outrider setup-local --repo owner/name --auto-interest --anthropic-key sk-ant-...

From the UI

Creating a Research Interest from a repo and choosing Set it up for me in Remyx Studio

Create a Research Interest from your repo and choose Set it up for me — no terminal required.

Identity and install

Either path pins the marketplace action at remyxai/outrider@v1. A same-repo install needs no github-token — the action self-mints a remyx-ai[bot] App token at runtime. Commits land authored by remyx-ai[bot] and show as Verified. You can also converse with a run by mentioning @remyx-ai on the PR or Issue; replies are read-only — see Deep Research.

Outrider’s artifacts carry Open Knowledge Format frontmatter. A repo-root CONTEXT.md and agent-instruction files (CLAUDE.md, AGENTS.md, CONTRIBUTING.md) sharpen its picks.

How it works

A run has two stages. The Remyx engine ranks a candidate pool server-side, then Outrider validates candidates against a clone of your repo and decides what to open. Ranking. The pool is ranked from three inputs: your interest’s context, your team’s shipping history (extracted from the merge log), and a learned preference model. Candidates that match the direction your team has shipped rank above topically similar ones. Validation and decision. A high relevance score does not mean a candidate is implementable; the top-ranked paper often has no call site in your repo. A selection pass checks each candidate against the codebase (code search and file reads) and picks the most implementable; if none fit, the run skips. Filters that do not call the model run first, so a run that cannot produce a useful result exits before any LLM cost. Each run ends in one of three outcomes: a draft PR, an Issue, or a skip.

Draft PR

The candidate integrates into an existing call site and passes the validators (tests, stub density, reachability). Outrider opens a draft PR with code and tests.

Discussion Issue

The candidate is relevant but not directly implementable (no call site, too many stubs, or unreachable code). Outrider opens an Issue with the attempted diff.

Skip

No candidate cleared the confidence, dedup, or fit gates. No artifact is created; the run records a status.

When chain is true (the default), opening a draft PR isn’t the end of the run. Outrider keeps going in the same run and walks the draft through three phases before it asks for review:

Fidelity

Diffs the draft against the paper’s reference implementation and emits a coverage matrix — what the diff covers, what it defers, and where it deviates from the source. When no public reference exists, it anchors the audit against the arXiv abstract instead; that’s lower precision and the PR body says so.

Convention

Rewrites the PR body to the repo’s canonical PR template, folds Outrider’s own scaffolding into a collapsible Discovery context block, and applies contributor conventions learned from recent merged PRs. Runs ruff auto-fix and force-pushes the result as the bot.

Test

Runs lint plus a focused pytest on the touched files. On a pass it flips the draft to ready-for-review; on failure the PR stays a draft for you to take over.

The Issue path gets a convention pass too: mode: issue-convention folds an Issue body to the repo’s ISSUE_TEMPLATE shape. Each phase reports its own Action output so you can gate downstream steps on them:

Output	Set by
`chain_fidelity_status`	Fidelity phase
`chain_convention_status`	Convention phase
`chain_test_status`	Test phase
`chain_issue_convention_status`	`issue-convention` pass on the Issue path
`chain_draft_dropped`	`true` if a phase dropped the draft rather than promote it

Set chain: false to stop after the first draft — Outrider opens the PR exactly as it first wrote it and runs none of the phases above. That’s the cheaper recommend-only mode.

Configuration

The defaults are conservative; most repos only touch interest-id and the schedule.

Input	Default	What it does
`interest-id`	(required)	The Research Interest UUID the run draws candidates from
`mode`	`recommend`	What the run produces: `recommend` (rank → validate → PR/Issue), `weekly-summary` (post a digest, see Weekly digest), `fidelity` / `convention` / `test` (run a single refinement phase standalone), or `issue-convention` (fold an Issue body to the repo’s `ISSUE_TEMPLATE`)
`chain`	`true`	After opening a draft PR, run the refinement chain inline in the same run (fidelity → convention → test). Set `false` for recommend-only — cheaper, leaves the draft as Outrider first wrote it
`min-confidence`	`moderate`	Skip recommendations below `high` / `moderate` / `low`
`draft-mode`	`always`	`always` (draft), `on_test_failure` (ready if tests pass), or `never` (skip on test failure)
`rate-limit-days`	`7`	Time-decayed cadence guard. Skip only if the most recently opened open Remyx artifact is younger than N days; older open artifacts age out and stop blocking. Merging or closing an artifact clears the guard immediately. `0` disables
`lookback`	`week`	Candidate pool window: `today` / `week` / `month`
`candidate-pool`	`25`	How many candidates the selection pass chooses from
`test-integration-policy`	`strict`	`strict` demotes to an Issue if new tests don’t import an existing module; `soft` opens a draft with a warning; `off` skips the gate. Use `soft` for component/library repos where a standalone module is the contribution
`guardrails-allowlist`	`''`	Extra path globs the agent may modify, on top of the defaults
`claude-timeout`	`900`	Wall-clock seconds for the implementation step. Raise for large repos, lower to cap cost
`pin-arxiv`	`''`	Implement one specific `arxiv_id` from the candidate pool and skip selection, for reproducible re-runs. Mutually exclusive with `pin-method`
`pin-method`	`''`	A free-text method query or a literal `arxiv_id`. Resolves the top match via engine search and implements it, bypassing the candidate pool and the selection pass. An explicit pin also overrides the don’t-re-recommend throttle, so you can re-run a paper that already has an open artifact. A strict superset of `pin-arxiv` that also works on ids outside the pool. Mutually exclusive with `pin-arxiv`
`model-base-url`	`''`	Override `ANTHROPIC_BASE_URL` for the Claude Code subprocess to route the coding agent at any Anthropic-Messages-compatible backend (z.ai/GLM, AWS Bedrock, GCP Vertex, an on-prem proxy). Put the backend’s key in `ANTHROPIC_API_KEY`, or in `ANTHROPIC_AUTH_TOKEN` for backends that authenticate with a Bearer token such as z.ai GLM. Cost telemetry becomes an estimate. See the action’s backends guide

Guardrails

Outrider constrains what the agent may change so a draft PR is reviewable:

Allowed: *.py anywhere, **/*.md, and the .remyx-recommendation/** spec bundle (scrubbed before commit).
Always blocked by file role (block list wins): .github/**, Dockerfiles, shell scripts, and dependency/build manifests (requirements*.txt, pyproject.toml, setup.py, lockfiles).
Edit-size caps: ≤50 net lines per edit to an existing file, ≤3 new .py files per run, and at least one new function/class must be invoked from another changed file (an import alone doesn’t count).

These caps are why a run picks an Issue over a PR when an honest implementation would be larger or more invasive than the guardrails allow.

Costs

You bring your own ANTHROPIC_API_KEY, so Claude Code usage is billed to you:

Claude Code: a full PR-route run with the inline chain is about $5–6. Recommend-only (chain: false) is $1–2. A run that skips after the selection pass costs less still — it reads the repo to verify fit, then exits.
GitHub Actions: ~6–8 min on ubuntu-latest per run.
Remyx API: included in your subscription.

With the default time-decayed cadence guard, typical engagement is ≈$2–4/month of Claude spend. Each run reports cost_usd, input_tokens, and output_tokens as Action outputs. Routing the coding agent at a cheaper backend with model-base-url lowers this (and turns the reported cost into an estimate).

Weekly digest

Run a second weekly cron with mode: weekly-summary and a weekly-discussion-id input to post a 7-day digest to a GitHub Discussion: outcomes, verified costs, license distribution, and open Issues with their next actions. It requires the discussions: write permission and costs about $0.10–0.20/week.

Run outcomes

Every run ends in a status in the Action log. The common ones:

Status	Meaning
`pr_opened` / `pr_opened_draft`	A PR was opened (ready or draft)
`issue_opened*`	Routed to an Issue — pre-flight, no integration found, too many stubs, or orphan code
`skipped_low_confidence`	Best candidate below `min-confidence`
`skipped_open_artifact`	An open Remyx artifact is still younger than `rate-limit-days` (the time-decayed cadence guard)
`skipped_by_selection_verification`	No candidate structurally fit the repo
`skipped_pr_exists` / `skipped_issue_exists`	Every candidate already has an open artifact
`skipped_issues_disabled`	The Issue route was needed but Issues are disabled (common on a fork) — enable Issues on the repo
`aborted_secret_in_payload`	The outbound secret scanner tripped on the draft payload; nothing was opened
`fidelity_*`	Outcome of the chain’s fidelity phase
`issue_convention_*`	Outcome of the `issue-convention` pass on the Issue path

The full status-code set is in the action’s README.

Reviewing an Outrider PR

Treat it like a first-pass proposal from a teammate:

Read the self-review in the PR body — what the integration covers and what it left out.
Run the diff and tests locally; the action runs pytest + an integration check, but your full suite is the real bar.
Decide — merge, push follow-ups, or close. With the GitHub integration connected, linking the PR to a Remyx experiment syncs its status automatically.

Same loop as Implement an experiment — Outrider just initiates it on a schedule.

Feed

Research Interests and the recommendations Outrider draws from

Connectors

The Remyx GitHub App and the remyx-ai[bot] identity

Outrider on GitHub

Action source, inputs, and full status-code reference

Introduction

Discover

Experiments

Manage

Admin

Concepts

Roadmap

Automated discovery PRs

Quickstart

From the CLI

From the UI

Identity and install

How it works

Draft PR

Discussion Issue

Skip

Refinement-pass chain

Configuration

Guardrails

Costs

Weekly digest

Run outcomes

Reviewing an Outrider PR

Feed

Connectors

Outrider on GitHub

​Quickstart

​From the CLI

​From the UI

​Identity and install

​How it works

Draft PR

Discussion Issue

Skip

​Refinement-pass chain

​Configuration

​Guardrails

​Costs

​Weekly digest

​Run outcomes

​Reviewing an Outrider PR

​Related

Feed

Connectors

Outrider on GitHub

Quickstart

From the CLI

From the UI

Identity and install

How it works

Refinement-pass chain

Configuration

Guardrails

Costs

Weekly digest

Run outcomes

Reviewing an Outrider PR

Related