Quickstart

Use the hosted website, install the terminal client, call the API, or connect your existing agent to individual Redgold tools. These paths use the same account, with separate permissions for models, search, browsers, data and compute.

Already using an agent? Start with agent tools setup for the copyable setup prompt, hosted MCP and remote-build requirements. You can keep your current model provider and repository workflow.

If you already have access, download the terminal client or start with the first project task. You can use the same project context to build, launch, and improve your work. A working application can grow into a product with users and permissions, payments, tested web releases, mobile-store preparation, and a plan to reach customers. You do not have to plan every stage before completing the first useful task.

1. Use the website

Open account access to see whether self-serve signup is available. When open, follow the account-creation flow there. Otherwise, request access and wait for an invitation. Existing account holders can sign in at redgold.ai. Requesting access does not immediately create an active workspace.

After signing in, the website detects an incomplete workspace and opens the onboarding flow. You can host code on your workspace's managed Gitea forge, which is available after you sign in, or connect GitHub and choose the repositories the redgold-ai GitHub App may access. Repository access stays limited to the repositories you select.

On the welcome step, describe your first task and choose Continue with this task to open it as a draft you can review before sending. You can also continue through optional workspace setup and choose Ask an agent to guide me at the end. That conversation is prepared with a setup request so an agent can check code hosting, repository access, provider keys, and the first task. The walkthrough is also available later from Setup → Ask an agent to guide setup.

Once setup is complete, give an AI coding agent a task. The agent runs on managed compute while the website keeps its conversation, tool calls, and session state available for later inspection.

The website is the starting point for account settings, workspaces, conversations, and API keys. You can begin here without installing a local client.

Finish your first project task

Choose one result you can inspect: a working page, a repaired bug, a comparison of possible approaches, or a launch brief. For code changes, connect the repository the agent should use. Confirm the available model/provider and account usage limits in setup before starting a long run.

For example, paste this into a conversation in the website or terminal and replace the bracketed text:

I'm working on [project and who it helps]. My next useful result is
[one working feature, repair, research answer, or launch deliverable].
Use [repository, website, or source material] and keep the scope to [boundary].
The result is ready when [observable acceptance condition].

Inspect the available context and tools, then complete that deliverable.
For code, follow the repository's instructions and run the relevant checks.
Show the result, what you checked, and anything that still needs attention.
Keep paid services and public posts in draft; I haven't authorized those.

For a concrete first change, ask for a project homepage that explains who it helps, shows one real example, and links to a working next step. Ask the agent to verify the page at desktop and mobile widths and check its links. Review the actual page and verification results before treating it as finished. Deployment depends on your connected environment and its release policy; a local change is not a published website.

If setup blocks the task, use Setup → Ask an agent to guide setup and include the error text without credentials.

Continue the same project through launch

Once the first feature works, ask the agent for the next product step in the same project. A class-booking app, for example, can add customer and instructor permissions, implement Stripe payments, pass its tests and CI checks, and publish a web version before preparing Android and iOS distribution. The landing page, campaign material, and feedback-driven fixes then stay connected to what you actually shipped.

Build, launch, and grow one project walks through that lifecycle and identifies the setup each stage needs. It covers current boundaries too: customer payments need their own integration, while the store settings currently prepare account connections and iOS signing rather than building and submitting customer releases. The optional USD 200 marketing budget helper is one small part of that broader workflow.

2. Install the terminal client

The redgold terminal client connects to the same conversations and remote agent sessions as the website. First sign in and open Settings → API Keys. Create an sk-rg- key and copy its full value when it is shown.

Export the key, run the installer, and add the installed binaries to your PATH:

export REDGOLD_API_KEY=sk-rg-...
curl -fsSL https://redgold.ai/install.sh | bash -s -- --without-engine --without-aws
export PATH="$PATH:$HOME/.redgold/bin"

Launch the terminal interface:

redgold

This installs redgold, the rac agent CLI and its rci CI companion, while omitting the optional local engine and AWS CLI. Search, browsing, memory and remote builds use their own configured services; fleet commands need managed fleet access. See Install the terminal client and tools for platform requirements and troubleshooting, and the RAC command guide for current workflows.

3. Use the API

Create an API key from Settings → API Keys and export it as shown above. Send the key as a bearer token to list the models available to your account:

curl https://api.redgold.ai/v1/models \
  -H "Authorization: Bearer $REDGOLD_API_KEY"

The response is an OpenAI-style model list. Use one of its model identifiers with the model API, or follow the first API call and Python client examples.

Use the API with coding agents

This optional setup changes the client's model provider. To keep your current provider and add tools instead, use agent tools setup or hosted MCP.

The same public API works as the model provider for Claude Code, Codex, Oh My Pi, and OpenCode. Choose a model from /v1/models that matches the client's wire format: Claude Code uses the Anthropic-compatible /v1/messages surface, while the examples for the other clients use the OpenAI-compatible /v1/responses or /v1/chat/completions surface.

For Claude Code, point the Anthropic base URL at the Redgold host and use a Messages-compatible model identifier:

ANTHROPIC_BASE_URL=https://api.redgold.ai \
ANTHROPIC_AUTH_TOKEN="$REDGOLD_API_KEY" \
ANTHROPIC_MODEL="model-id-from-v1-models" \
ANTHROPIC_SMALL_FAST_MODEL="model-id-from-v1-models" \
claude

For Codex, add a custom Responses provider to $HOME/.codex/config.toml:

model = "redgold-flint"
model_provider = "redgold"

[model_providers.redgold]
name = "Redgold"
base_url = "https://api.redgold.ai/v1"
env_key = "REDGOLD_API_KEY"
wire_api = "responses"

Then run codex normally. Replace redgold-flint with another Responses-compatible identifier returned for your account when appropriate.

For Oh My Pi, define the provider in $HOME/.omp/agent/models.yml:

providers:
  redgold:
    baseUrl: https://api.redgold.ai/v1
    apiKey: REDGOLD_API_KEY
    api: openai-responses
    models:
      - id: redgold-flint
        name: Redgold Flint

Start omp and select redgold/redgold-flint from /model.

For OpenCode, run /connect, choose Other, enter redgold as the provider ID, and paste the API key. Then add the provider to your project-level opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "redgold": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Redgold",
      "options": {
        "baseURL": "https://api.redgold.ai/v1"
      },
      "models": {
        "redgold-flint": {
          "name": "Redgold Flint"
        }
      }
    }
  }
}

Run /models in OpenCode and select the Redgold model. Clients built around the newer Responses API can use OpenCode's @ai-sdk/openai adapter instead.

Optional session orchestration works behind the same coding-client connection. When it is enabled for your account, keep using the client normally: Redgold triages each request, gathers focused analysis in parallel, and supplies the combined context to the model producing the response. The client continues to receive its standard streamed response, so its commands, tool use, and project instructions work the same way.

Continue

Pipeline applications turn a description of what you need into a managed app. Coding agents prepare the application for your review, and Redgold operates its data, workflows, API, and deployment. Continue with Pipeline Applications to see how a support request becomes a running application and what you control along the way.

Use the common task index to find another guide, or browse the examples for step-by-step recipes. How Redgold works explains how pipeline applications, data, coding agents, model access, and managed deployment fit together.