How to Use Claude Code on Agent.Space: A Workspace Guide

Using Claude Code on Agent.Space means running the Claude Code Agent harness inside a persistent cloud Workspace. Claude Code can investigate the codebase, edit files, run development commands, and verify work; the Workspace keeps the project files, Sessions, supported Previews, and explicit handoff state together.

The safest first workflow is to create or open a Workspace, supply only the relevant project context, select Claude Code and a compatible model, ask it to investigate before editing, and review the saved evidence against written acceptance checks. The Claude Code Agent page is the current Hub for availability and related guides.

This route adds an Agent.Space project layer around the harness. It does not reproduce every Anthropic-native Claude Code interface or turn an Agent.Space plan into an Anthropic subscription or Console balance.

Product details verified: 2026-09-02. Harness, model, feature, and plan availability can change. Check the live Agent.Space selectors and current Anthropic documentation before relying on a combination.

What using Claude Code on Agent.Space means

Anthropic describes Claude Code as an agentic coding tool that reads a codebase, edits files, runs commands, and integrates with development tools. In Agent.Space, that harness works as one participant inside a larger project boundary:

These layers can change independently. Choosing a different compatible model does not automatically create a different harness workflow. Starting a new Session does not delete the Workspace files. Bringing in another supported Agent does not require abandoning the Workspace or rebuilding the project context from scratch.

The Agent.Space product architecture explains the complete model. For this guide, the key point is simple: Claude Code performs the task; the Workspace preserves the inspectable project state around it.

When this Claude Code route fits

Evaluate Claude Code on Agent.Space when the project needs more than one private terminal conversation:

• the current files should remain available between work periods;
• a teammate needs to inspect or continue from the same project state;
• another supported Agent may review the result in a separate Session;
• a supported Preview or artifact should stay beside the task context; or
• you prefer a managed cloud Runtime for this workload.

Use an Anthropic-native Claude Code surface when a feature specific to the current CLI, IDE, Desktop, Web, mobile, or integration experience is essential. Anthropic’s platform guide lists those surfaces and makes clear that execution location and interface vary. Use a self-managed environment when your organization must directly operate the complete Runtime, network, and credential boundary.

The decision should follow the project: where its files must live, who must review them, how the task should resume, and which native capability is required.

If the decision is specifically between Anthropic's harness and Cursor's editor-plus-agent workflow, use the focused Claude Code vs Cursor comparison.

Start a Claude Code Session in five steps

1. Create a Workspace for the outcome

Use a project name such as Billing migration review or Docs search repair, not Claude experiment. A durable name keeps the Workspace understandable if a teammate or another Agent later joins.

2. Add the brief and necessary files

State the desired result, authoritative source, allowed scope, excluded scope, and acceptance checks. Add only the files needed to make those constraints real. Keep credentials and unrelated private material out of prompts and ordinary project files.

3. Choose Claude Code

Start a new Session and select Claude Code as the Agent harness. Treat the live selector as the current availability record rather than depending on a dated guide or internal version number.

4. Choose a compatible model separately

Select from the models currently offered for Claude Code in the product. A model existing in an API catalog does not guarantee that it works in every harness or interface. If you need to compare or switch model routes without confusing the model with the harness, use the Claude Code model-switching and hooks guide.

If your account can use Anthropic's current Fable route, the focused guide to select Fable 5.1 and adjust effort in Claude Code covers the native CLI commands and access checks. That upstream availability does not prove the same model is offered in Agent.Space; check the live selector here separately.

5. Begin with investigation, then act

Ask for a bounded change or diagnosis. For an unfamiliar repository, have Claude Code first locate the relevant code, restate the scope, identify uncertainty, and propose checks. Let it edit only after the intended boundary is clear.

Use a plan-first task contract

Anthropic explains the Claude Code agentic loop as gathering context, taking action, and verifying the result. A practical prompt makes those phases reviewable:

GoalProduce [specific, observable result].
Authoritative context- Follow [brief, file, issue, or requirement].- Inspect [relevant area] before changing anything.
Scope- You may change [files or behavior].- Do not change [protected area].
Plan checkpointFirst summarize the current behavior, likely cause or approach, files involved,and validation plan. Stop if a product or architecture decision is required.
Acceptance checks- [test, build, Preview state, or content rule]- [second condition]
Before finishingList changed files, checks run, checks not run, assumptions, and open risks.

This is not a claim that every task needs a long planning phase. A one-line copy fix may not. The checkpoint is useful when a wrong assumption could spread across multiple files or when a person owns the final design or architecture decision.

Review saved evidence and prepare the next Session

Claude Code’s summary tells you what it believes happened. Verify the actual project state:

1. Compare the output with the acceptance checks.
2. Inspect every changed file and watch for expanded scope.
3. Open a supported Preview or artifact when the result is visual.
4. Review test, build, lint, type-check, or other relevant output.
5. Separate passed checks from checks that were skipped or could not run.
6. Record assumptions, remaining decisions, and the safest next action.

If a teammate or another Agent will continue, put that information in an inspectable handoff. Start a separate Session in the same Workspace when the next task belongs to another harness. The new Session can inspect the current saved files and explicit handoff, but it does not silently inherit Claude Code’s hidden reasoning.

If the useful context currently lives in a local conversation, use the controlled process to import selected Claude Code conversations. The imported conversation does not bring the local project directory with it, so reconcile history with the Workspace files before editing.

What remains an Anthropic decision

Agent.Space is independent from Anthropic. It is not a Claude subscription, Console/API balance, Anthropic reseller, shared login, Claude Managed Agents deployment, or way around Anthropic’s account, payment, regional, automation, or usage rules.

Anthropic still determines:

• Claude Code’s core behavior and native interfaces;
• Claude model capabilities and upstream feature eligibility;
• subscription, Console/API, cloud-provider, and authentication rules;
• features available only in Anthropic’s CLI, IDE, Desktop, Web, or integrations; and
• Anthropic terms and data controls for those accounts.

For example, Anthropic’s current authentication guide gives subscription OAuth, Console credentials, and supported cloud providers different ownership and precedence rules. Running the Claude Code harness in an independent Workspace does not merge those products or balances.

If authentication and bill ownership are the main issue, use the separate Claude Code subscription, API, and managed Workspace comparison.

A safe first Claude Code run

Confirm one end-to-end loop before expanding:

• Selection: Claude Code and the intended compatible model appear in the live product.
• Scope: the task names what may and may not change.
• Checkpoint: any subjective product or architecture choice returns to a person.
• Evidence: saved files and relevant checks support the claimed result.
• Recovery: the change is small enough to revise or reverse.
• Continuity: another participant can understand the state from files and a written handoff.

The first run is complete when the result is inspectable, the uncertainty is explicit, and the next step does not depend on reconstructing a private conversation. Add more files, longer work, other Agents, or teammates only after that foundation holds.