Actions

Set up from: Agents > + Set up an agent or the remyxai CLI | Runs in: your repo’s GitHub Actions Remyx agents ship as actions — workflows that run in your own repo’s CI, on your own keys, reporting evidence back to the platform. Outrider is the first, one of more to come: a GitHub Action that discovers ideas that fit your codebase, drafts PRs for the most actionable changes, and files issues for ideas worth watching. This page documents that runtime — what a run does, its configuration inputs, guardrails, costs, and outcomes. The telemetry every run reports is what powers the agent report, Reports, and the Inbox.

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 a model provider — Anthropic (Claude), Z.ai (GLM), or Moonshot (Kimi) — is required to draft implemented PRs (billed to your provider 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[bot]. (details)

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

From the UI

Use + Set up an agent on the Agents page (or 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[bot] App token at runtime. Commits land authored by the bot (GitHub identity remyx[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.

The Outrider pipeline: external sources and your repo feed the Remyx engine's ranking; the action fetches the candidate pool, gates it, selects the most implementable candidate, implements within guardrails, validates, and routes to a draft PR, an Issue, or a skip — with the refinement chain promoting PRs and run telemetry feeding back into ranking

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-blocklist`	`''`	Path globs the agent must not touch (e.g. `secrets/*`, `.lock`), added on top of the fixed default block (`.github/workflows/**`). Blocklist matches always win. (`guardrails-allowlist` is deprecated as of v1.7.24 — path access is permissive-by-default and the old input is a no-op)
`publish`	`pr`	`pr` opens a draft PR and runs the inline chain; `branch` pushes the branch only — no PR, no chain, zero maintainer-facing artifact until the team opens the PR themselves. Branch mode is the drafter tier of the two-tier pattern
`provider`	`''`	Route the coding agent at a named backend: `anthropic`, `zai`, `moonshot`, or `custom`. Sets the base URL and auth style and clears the conflicting auth var; pass each backend’s secret in the step’s `env:`. Empty preserves legacy behavior. See Model backends
`model`	`''`	Model to request from the provider (e.g. `claude-opus-4-8`, `glm-5.2`, `kimi-k3`), forwarded as `ANTHROPIC_MODEL`; also keys the per-model cost rate table
`start-from-ref`	`''`	Branch/tag/SHA on the target fork to start the coding session from — the agent sees that ref’s diff already applied, enabling refinement runs on a prior draft. The result pushes to a `<paper-slug>-refined` branch
`lead-content`	`''`	A scoped implementation spec (e.g. a gap analysis, or a LEAD Issue’s content — Linear URLs resolve via `linear-api-key`) that replaces the paper’s suggested experiment in the run’s SPEC.md
`fidelity-policy`	`block`	Pre-PR fidelity gate: `block` (one scoped patch attempt on a needs-judgment verdict, then skip — keeps hallucinated implementations out of public PRs), `advisory` (audit attaches its coverage matrix but never blocks — best for curated warm-start runs), or `off`
`staged-synthesis`	`false`	Opt-in two-stage session: a bounded research pass first (target-repo state, prior attempts, conventions), then coding reads its findings. Adds ~$0.15–0.50 and ~1–3 min
`maintain-state`	`false`	Opt-in per-fork cross-run learning via `.remyx/repo_intel.yaml`: confirmed landing zones, rejected mechanism shapes, exploration budget
`enable-cocoindex`	`true`	Installs AST-based semantic code search as a runner skill, grounding call-site claims on real paths (adds ~60–90s and ~1 GB of deps to the run; also powers the “Convention precedents” enrichment on Issue bodies). Disable to slim the runner
`claude-timeout`	`1500`	Wall-clock seconds for the coding-agent calls; every phase shares the ceiling. Raise to `3600` for the Z.ai / Moonshot backends (thinking-mode latency), lower to cap cost
`pin-arxiv`	`''`	Implement one specific `arxiv_id` and skip the selection pass, for reproducible re-runs and warm starts. Falls back to fetching the paper directly from arxiv.org when it isn’t in the Remyx catalog (`skipped_pin_arxiv_unresolvable` if neither resolves). Mutually exclusive with `search-method`
`search-method`	`''`	A free-text method query. 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. Mutually exclusive with `pin-arxiv`. (The CLI exposes this as `remyxai outrider trigger --pin-method`)
`model-base-url`	`''`	Override `ANTHROPIC_BASE_URL` to route the coding agent at a custom Anthropic-Messages-compatible endpoint (AWS Bedrock, GCP Vertex, an on-prem proxy). For the known backends prefer `provider: zai` / `provider: moonshot`. Cost telemetry becomes an estimate. See Model backends

Guardrails

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

Fixed block: .github/workflows/** is always off-limits — it guards against agent-authored edits that would silently expand the run’s own future agency. guardrails-blocklist adds your own globs on top (e.g. secrets/**, *.lock, Dockerfile*), and blocklist matches always win.
Integration checks (post-session, pre-push): at most 3 new .py files per run, and at least one newly added function or class must be invoked from another changed file — an import alone doesn’t count. Violations terminate the run before any push (rejected_path_violations); orphan code downgrades the run to an Issue.
Validators: stub-density, the test-integration gate, a self-review orphan check, a diff-risk score gate, and an outbound secret scan — each with its own Issue-route or abort status.

These gates are why a run picks an Issue over a PR when an honest implementation would be larger or riskier than a reviewable draft.

Costs

You bring your own model-provider key (any backend), so model usage is billed to you:

Model usage: on Anthropic, a full PR-route run with the inline chain is about $5–6; recommend-only (chain: false) is $1–3. On the Z.ai or Moonshot backends a run is roughly 20× cheaper. 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 model spend. Each run reports cost_usd, input_tokens, and output_tokens as Action outputs; on Z.ai and Moonshot the cost is computed from a per-model rate table. Reports → Costs turns this telemetry into fleet unit economics, and the two-tier drafter/refiner pattern is the structured way to spend less per artifact.

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. Your call feeds the agent’s Direction either way, and the Inbox card clears itself when GitHub records the merge or close.

Merged and closed PRs feed back into the agent’s Direction — every decision re-weights what it proposes next.

Agents

Install and manage agents from the app

Model backends

Anthropic / Z.ai / Moonshot, the provider input, and the two-tier pattern

Connectors

The Remyx GitHub App and the remyx[bot] identity

Outrider on GitHub

Action source, inputs, and full status-code reference

Get started

Discover

Agents

Review & decide

Configure

Background

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

Agents

Model backends

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

Agents

Model backends

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