remyxai/Remyx Outrider

Scouts arXiv for the next paper most implementable against your codebase and drafts a PR or opens an issue.

View on GitHub

Trust Signals

Scorecard Score: not yet scored
Maintenance Recency: Activelast commit Jul 10, 2026
License: Apache 2.0

Pinned Snippet

workflow.ymlSHA-pinned

uses: remyxai/outrider@76c392bd13b2eeae17e875d61524c99043c75c9a # v1.7.15

tags can be moved; commit SHAs can't. why a SHA?

Inputs

name	description	required	default
interest-id	Remyx ResearchInterest UUID. Get it from engine.remyx.ai → your interest's detail page → "Workflow snippet" tab.	yes	—
mode	Run mode: - "recommend" (default): scout a paper, draft a PR or open an Issue — the classic per-run flow. - "weekly-summary": aggregate the past 7 days of Outrider runs on this repo and post a digest comment to the Discussion named by `weekly-discussion-id`. Opt-in; customers add a second scheduled job (weekly cron) that calls the action in this mode. Requires `discussions: write` in the workflow's permissions block. - "fidelity": audit a remyx-ai[bot] draft PR against its paper's reference impl, append a structured ``## Coverage`` matrix to the PR body, and transition the PR's labels (outrider:draft → outrider:fidelity-done, or outrider:needs-judgment when an item flags for human review). Triggered by the workflow on ``pull_request: labeled`` with name=outrider:draft; requires ``pr-number`` to be set (from the event payload). Read-only for the codebase (only mutates the PR body + labels). - "convention": extract contributor conventions from the target repo's (or upstream's, for forks) recent merged PRs, identify convention-shape misalignments in the draft, run an agentic patch session bounded to non-algorithmic changes, force-push with bot attribution, and post an evidence comment listing the patterns + their source PRs. Triggered by ``outrider:fidelity-done``; requires ``pr-number``. - "test": run lint + targeted tests on the PR's added/modified files, write a ``## Refinement checks`` section to the action's run-summary panel, drop the PR's draft state on a passing run (the canonical GitHub "ready for review" signal), and apply the ``outrider:test-failed`` label only on hard failure (lint surfaced issues or tests failed). PR body is untouched — that's the convention pass's surface. Triggered after the convention pass; requires ``pr-number``. - "issue-convention": fold an Outrider-drafted Issue's body to the target repo's ``.github/ISSUE_TEMPLATE/`` shape (markdown frontmatter or Issue Forms). Picks the best-fitting template via a single Claude one-shot (filtering out bug/question kinds), then PATCHes the Issue body. Mirrors the PR-route convention pass but with no diff to patch, no draft state, and no test gate — just the body rewrite. Triggered inline in recommend mode when routing to Issue, or explicitly via a standalone ``mode: issue-convention`` workflow_dispatch; requires ``issue-number``.	no	recommend
chain	When true (default), recommend mode automatically continues into the refinement chain (fidelity audit → convention pass → test gate) on the draft PR it just filed, within the same workflow run. This is the zero-config rollout: customers get the full chain without deploying the standalone outrider-fidelity / outrider-convention / outrider-test workflows or wiring the label triggers. Set to 'false' for cost-sensitive runs (recommend-only is ~$1-3 vs ~$5-6 with the chain) or when you intentionally run the chain via the separate-workflow pattern with `mode: fidelity/convention/test`.	no	true
pr-number	PR number to operate on. Read in the per-phase chain modes (``fidelity`` / ``convention`` / ``test``); set from the workflow's pull_request event payload (or a workflow_dispatch input) when driving a single phase against an existing PR. Empty in recommend / weekly-summary modes — the inline chain (``chain: true``, default) threads the just-opened PR number through automatically, so most installs never set this.	no	""
issue-number	Issue number to operate on. Read in ``mode: issue-convention`` only; set from the workflow's issues event payload (or a workflow_dispatch input) when driving the Issue-route convention pass against an existing Issue. Empty in recommend / weekly-summary modes — the inline chain (``chain: true``, default) threads the just-opened Issue number through automatically when recommend mode routes to an Issue instead of a PR, so most installs never set this.	no	""
weekly-discussion-id	Target Discussion for weekly-summary mode. Accepts the Discussion number (from its URL) or the GraphQL node ID. Only read when `mode: weekly-summary`; the mode skips cleanly when empty.	no	""
github-token	GitHub token used for git push, PR / Issue creation, and the existing-PR dedup check. Leave empty for the standard same-repo install — the action self-mints a remyx[bot] token from engine.remyx.ai (using REMYX_API_KEY) so artifacts are authored by the Remyx App by default, and falls back to the workflow's built-in github.token when minting isn't available. Override with a PAT only for cross-repo controller patterns (action runs in repo A but writes PRs to repo B); the PAT needs `repo` scope on the target.	no	""
min-confidence	Tier gate. Recommendations below this confidence are skipped. One of: "high" \| "moderate" \| "low". Default: moderate.	no	moderate
draft-mode	PR-draft policy: - "always": every PR opens as draft (default; future Modal-eval webhook will flip to ready) - "on_test_failure": tests pass → ready, tests fail → draft - "never": tests pass → ready, tests fail → skip	no	always
rate-limit-days	Cadence guard window. Skip the run if the most recently opened Remyx Recommendation artifact (PR or Issue) on the target repo is younger than this many days. Older open artifacts age out of the throttle window and stop blocking — real maintainers leave Issues open for weeks without active triage, and the action should resume cadence rather than mute the repo indefinitely. Engagement (merge or close) still clears the gate immediately. Per-paper dedup (a separate gate) handles same-recommendation retries — this guard is purely about not stacking recent unresolved work. Set to 0 to disable the guard entirely (useful for batch trials).	no	7
guardrails-allowlist	DEPRECATED (v1.7.24) — no-op. Path allowlisting is permissive-by- default; the coordination-issue + PR-review + integration-check layers replace the narrow allowlist that earlier versions used. Setting this input logs a deprecation warning and is otherwise ignored. Removal planned in v2. Use `guardrails-blocklist` if you need explicit file protection.	no	""
guardrails-blocklist	Comma-separated path globs the coding agent must NOT touch, ADDED ON TOP OF the fixed default block (`.github/workflows/`, which guards against agent-authored edits that would silently expand this run's own future agency). Empty by default — the standard operating model relies on human review + coordination-issue-first policy for legitimacy checks, not on path pattern matching. Set this for defense-in-depth on teams with policy requirements — e.g. `secrets/`, `.lock`, or `Dockerfile`. Matches take precedence over the (now-permissive) allowlist.	no	""
test-integration-policy	How to handle the test-integration gate, which requires that new tests import from a pre-existing module (or that an existing package module imports the new module). One of: strict (default) — if the gate fails, route the run to an Issue instead of opening a PR. Best for application/ pipeline repos where standalone-module contributions are usually scaffold-shaped. soft — if the gate fails, still open the PR as a draft and add a warning section to the body noting the missing integration. Best for layer/component repos (graph NN, kernels) where a new standalone module IS the contribution. off — skip the gate entirely. Relies on the other validators (path allowlist, integration check, stub density, self-review) to keep PRs honest.	no	strict
fidelity-policy	How the pre-PR fidelity gate treats a needs-judgment verdict (the audit that compares the drafted diff against the paper's reference implementation before opening the PR). One of: block (default) — a needs-judgment verdict blocks publication: one scoped patch attempt, then skip if it still flags (branch mode preserves the branch instead). Keeps fabricated / hallucinated implementations out of public PRs. Best for autonomous runs on arbitrary repos. advisory — run the audit and attach the "## Coverage" matrix, but never block: the PR opens even when items are flagged. Best for curated or warm-start runs (start-from-ref) where a human already vetted the branch and a strict full-reference-port comparison is the wrong lens for a scoped integration. Reuses the existing medium-confidence advisory path. off — skip the gate entirely (no reference clone, no audit). The other validators (path allowlist, integration check, stub density, self-review, diff-risk) still apply. Independent of the medium-confidence auto-advisory behavior, which still applies under `block` when the reference doesn't self-identify strongly with the paper.	no	block
lookback	Recommendation lookback window. The action pulls the candidate pool over this window, then a Claude selection pass picks the candidate most directly implementable against the target repo (relevance rank alone often surfaces a model-architecture paper with no call site). One of: "today" \| "week" \| "month". Default: "week" (past 7 days).	no	week
candidate-pool	How many recommendations to pull into the selection pool over the lookback window. The selection pass picks the most implementable one; the rest are recorded as "rejected" with a reason. Default 25 (the API returns up to whatever Remyx retains for the interest, so a larger pool just widens the window the selection pass sees).	no	25
claude-timeout	Wall-clock seconds for the Claude Code agent calls (preflight routing + implementation). Default raised to 1500s in v1.7.24 (previously 900s) — GLM sessions with staged-synthesis routinely reach 15-20 min, and users triggering runs without prior tuning were hitting the old 15-min ceiling. Opus refinement sits comfortably under 25 min at the new default. Both stages share the same ceiling so a single knob covers per-dispatch budget tuning. Bump for very large codebases or slower non-default backends; lower to cap cost.	no	1500
lead-content	Optional scoped implementation spec (verbatim LEAD content from a prior Outrider Issue's `lead_content` field). When set, replaces the paper's `suggested_experiment` in SPEC.md — Claude Code's implementation is driven by the LEAD's scoped experiment rather than the paper's own contribution framing. Use this to convert a LEAD Issue into a Draft PR without changing the paper reference (dispatch with pin-arxiv=<paper> + lead-content=<LEAD's scoped experiment>). Empty = normal paper-driven implementation.	no	""
pin-arxiv	Optional arxiv_id. When set and present in the candidate pool, the action implements that exact paper and skips the LLM selection pass — use it for reproducible eval re-runs. Empty = normal selection.	no	""
search-method	Free-text method/technique query (e.g. "riemannian preconditioning LoRA optimizer"). When set, Outrider runs the engine's search to find the top-hit arxiv paper matching the query and implements it — overriding the interest's ranked pool. Use for exploratory dispatches when you know the method family but not the specific arxiv id. For reproducible re-runs of a known paper, use pin-arxiv instead. Empty = normal selection. Mutually exclusive with pin-arxiv.	no	""
publish	What to produce at the end of a recommend-mode run: - "pr" (default): current behavior — push branch, open Draft PR, run the inline chain (fidelity → convention → test). - "branch": push the branch to the fork, but SKIP PR creation and SKIP the inline chain. Coordination signal and evidence land in the workflow step summary + workflow artifact only. Team reviews the branch via `gh` / GitHub UI and runs `gh pr create` themselves when ready to ship. Zero maintainer-facing artifact until the team explicitly opens the PR. Useful for batched multi-candidate exploration where you want to review before committing to shipping.	no	pr
staged-synthesis	Opt-in two-stage coding session: a bounded research invocation runs first, produces `web_findings.json` in the workspace, then the coding invocation reads it as structured context alongside SPEC.md. The research invocation decomposes the paper into parallel research subquestions (target-repo state, prior attempts, coordination signals, convention patterns), dispatches concurrent tool calls, and aggregates into a typed handoff artifact. When enabled, adds ~$0.15-0.50 and ~1-3 minutes to the run. The coding session's INVOCATION.md gains a "Research context" section referencing `web_findings.json`. Downstream refinement-chain agents (fidelity / convention / test) also read the artifact, avoiding re-discovery. Empty / 'false' (default) = classic single-invocation flow.	no	false
maintain-state	Opt-in per-fork cross-run learning. When 'true', Outrider reads `.remyx/repo_intel.yaml` from the fork's main branch (if present) and threads it into the coding session as REPO_INTEL.md. The file carries confirmed landing zones (where prior branches landed cleanly), rejected mechanism shapes (with the reasons they didn't fit and caveats under which the rejection might not apply), coordination signals, and exploration budget accumulated across prior dispatches on this fork. The coding session consults it before picking a call site so it can extend confirmed landings instead of re-discovering them, and avoid known-rejected shapes unless a caveat matches. Never fails a run when the file is missing / malformed / unreadable. Empty / 'false' (default) = classic flow without cross-run state.	no	false
linear-api-key	Linear API key used by the tool-plane's Linear connector to resolve `lead-content` URLs of the form `linear.app/<workspace>/issue/<ID>`. When set, a Linear issue's body + top-level metadata is fetched and substituted into the coding session's SPEC.md in place of the URL, so the agent gets structured phase-spec content rather than a login page via WebFetch. Empty (default) = the Linear connector reports `not_configured` per fetch attempt, and the URL falls through to today's WebFetch flow. No auth wire-up required for forks that don't use Linear-based lead-content.	no	""
start-from-ref	Optional branch/tag/SHA on the target fork to start the coding session from, instead of the repo's default branch. Enables refinement runs on a prior Outrider draft (e.g. add tests, apply convention pass, fix a failing gate) — the agent sees the ref's diff already applied to the workspace, so `lead-content` phrasing like "add coverage for X" or "refactor Y" becomes actionable rather than advisory. Semantics: clone the target fork, `git fetch` + `git checkout` this ref, run the coding session on top. The eventual push lands on a new branch named `<paper-slug>-refined` (suffix avoids the collision when the same paper feeds both the original and refinement run). PR is still opened against the repo's default branch, so the diff review shows the full state — original artifact plus refinement — in one place. Empty (default) = clone default branch (main / master), the classic per-paper implementation flow.	no	""
model-base-url	Optional override for the Claude Code subprocess's ANTHROPIC_BASE_URL. Use this to route the coding agent to any Anthropic-Messages-compatible backend — e.g. z.ai's GLM Coding Plan, AWS Bedrock, GCP Vertex, an on-prem proxy. The ANTHROPIC_API_KEY repo secret should hold the backend's API key when this is set, not your Anthropic key. Empty (default) = api.anthropic.com. Note: when set, the `total_cost_usd` that the Claude Code CLI reports is computed with Anthropic-rate pricing applied to the backend's tokens — it's an estimate, not a bill. Token counts remain accurate. For the known backends `zai` / `moonshot`, prefer the `provider` input below — it configures both this URL and the correct auth env var (Bearer vs x-api-key) from a single field, and picks up the right per-vendor secret without a fork-side case-switch. Use `model-base-url` directly only for custom / on-prem endpoints not covered by the `provider` shortlist.	no	""
provider	Which Anthropic-Messages-compatible backend to route the coding agent at. Consolidates the auth-env + base-URL wiring that forks previously duplicated in a workflow-level Configure step. Recognized values: - `` (empty, default): existing behavior — pass through `model-base-url` as-is, no auth manipulation. Backward-compatible. - `anthropic`: default Anthropic API. Requires `ANTHROPIC_API_KEY` in the caller's env block. - `zai`: z.ai GLM Coding Plan. Requires `ZAI_API_KEY` in the caller's env block. Sets `ANTHROPIC_AUTH_TOKEN` (Bearer) and `ANTHROPIC_BASE_URL=https://api.z.ai/api/anthropic`. - `moonshot`: Moonshot Kimi. Requires `MOONSHOT_API_KEY` in the caller's env block. Sets `ANTHROPIC_AUTH_TOKEN` (Bearer) and `ANTHROPIC_BASE_URL=https://api.moonshot.ai/anthropic`. - `custom`: use `model-base-url` + caller-supplied auth env var for anything not in the shortlist above. Secrets aren't magically visible inside the composite action — the caller MUST pass the required secret via the `env:` block on the `- uses: remyxai/outrider@v1` step (see docs/backends.md for the canonical shape). The action fails clean with a specific error if the required secret env var is missing.	no	""
model	Optional model name — sets `ANTHROPIC_MODEL` for the Claude Code subprocess. When set, cost telemetry looks up the specific per-model rate in the backend rate table (see `_BACKEND_RATES` in src/run.py) rather than falling back to the host's flagship-tier default. Examples: `claude-opus-4-8`, `claude-haiku-4-5`, `glm-5.2`, `glm-4.6`, `kimi-k3`, `kimi-k2.7-code`, `kimi-k2.7-code-highspeed`. Empty (default) → the caller's own `ANTHROPIC_MODEL` env var wins if set; otherwise the backend picks its own default and cost telemetry uses the host's flagship-tier rates.	no	""
enable-cocoindex	Install cocoindex-code as a Claude Code skill on the runner so the selection + implementation agent has AST-based semantic code search available (grounds call-site claims on real paths instead of speculating). Adds ~60-90s to the run's install phase and ~1 GB of torch/transformers deps to the runner. Set to 'false' to skip. Also gates the "Convention precedents (via cocoindex AST search)" enrichment on Issue bodies — the post-drafting convention- verification section requires ccc on PATH to fire, so turning this off silently drops that enrichment too.	no	true

Outputs

name	description
status	Run outcome: "pr_opened" \| "pr_opened_draft" \| "issue_opened" \| "skipped_low_confidence" \| "skipped_open_artifact" \| "skipped_issues_disabled" \| "skipped_pr_exists" \| "skipped_issue_exists" \| "skipped_test_failure" \| "claude_failed" \| "skipped_no_method_match" \| "rejected_path_violations" \| "aborted_secret_in_payload" \| "error". In weekly-summary mode: "weekly_summary_posted" \| "weekly_summary_skipped_no_discussion_id" \| "weekly_summary_failed".
discussion_comment_url	URL of the posted weekly-summary Discussion comment (set when status == "weekly_summary_posted").
pr_url	URL of the opened PR (set when status starts with "pr_opened").
issue_url	URL of the opened Issue (set when status == "issue_opened").
arxiv	arxiv_id of the recommended paper.
tier	Confidence tier of the recommendation (high / moderate / low / noise).
cost_usd	Total Anthropic cost (USD) across all Claude passes this run.
input_tokens	Total input tokens across all Claude passes this run.
output_tokens	Total output tokens across all Claude passes this run.