> ## Documentation Index
> Fetch the complete documentation index at: https://docs.remyx.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Actions
> Remyx agents ship as actions that run in your own CI. Outrider — recent research into draft PRs — is the first.
**Set up from:** [Agents > + Set up an agent](/platform/agents/overview#set-up-an-agent) or the [`remyxai` CLI](/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](/platform/agents/overview#the-agent-report), [Reports](/platform/review/reports), and the [Inbox](/platform/review/inbox).
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](/platform/configure/connectors) view. The [**GitHub**](/platform/configure/connectors#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**](/platform/configure/connectors#model-providers) — 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](/platform/configure/account#api-access).
Either path provisions the workflow and fires the first run. A draft PR or Issue lands in minutes.
### From the CLI
```bash theme={null}
pip install remyxai
# authenticate the CLI with your Remyx API key
export REMYXAI_API_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 ` 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](/cli#install-without-the-github-app))
```bash theme={null}
remyxai outrider setup-local --repo owner/name --auto-interest --anthropic-key sk-ant-...
```
### From the UI
Use [**+ Set up an agent**](/platform/agents/overview#set-up-an-agent) on the Agents page (or create a [Research Interest from your repo](/platform/discover/feed#research-interests-from-a-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](/platform/discover/briefs).
Outrider's artifacts carry [Open Knowledge Format](https://github.com/remyxai/outrider) 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 candidate integrates into an existing call site and passes the validators (tests, stub density, reachability). Outrider opens a draft PR with code and tests.
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.
No candidate cleared the confidence, dedup, or fit gates. No artifact is created; the run records a [status](#run-outcomes).
***
## Refinement-pass chain
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:
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.
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.
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](#weekly-digest)), `fidelity` / `convention` / `test` (run a single [refinement phase](#refinement-pass-chain) 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](#refinement-pass-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](/platform/agents/backends#the-two-tier-drafter-refiner-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](/platform/agents/backends#the-provider-input) |
| `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 `-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](/platform/agents/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](/platform/agents/backends)), so model usage is billed to you:
* **Model usage:** on Anthropic, a full PR-route run **with the inline [chain](#refinement-pass-chain)** is about **\$5–6**; recommend-only (`chain: false`) is **\$1–3**. On the [Z.ai or Moonshot backends](/platform/agents/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](/platform/review/reports#costs) turns this telemetry into fleet unit economics, and the [two-tier drafter/refiner pattern](/platform/agents/backends#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](#refinement-pass-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](https://github.com/remyxai/outrider#status-codes).
***
## Reviewing an Outrider PR
Treat it like a first-pass proposal from a teammate:
1. **Read the self-review** in the PR body — what the integration covers and what it left out.
2. **Run the diff and tests** locally; the action runs `pytest` + an integration check, but your full suite is the real bar.
3. **Decide** — merge, push follow-ups, or close. Your call feeds the agent's [Direction](/platform/agents/overview#direction) either way, and the [Inbox](/platform/review/inbox) card clears itself when GitHub records the merge or close.
Merged and closed PRs feed back into the agent's [Direction](/platform/agents/overview#direction) — every decision re-weights what it proposes next.
***
## Related
Install and manage agents from the app
Anthropic / Z.ai / Moonshot, the provider input, and the two-tier pattern
The Remyx GitHub App and the remyx\[bot] identity
Action source, inputs, and full status-code reference