Workspace View

Once a project is created and its repository is connected, day-to-day development happens inside Chat Trials. This is the primary workspace where you collaborate with agents, explore the codebase, implement changes, run commands, and review results.

Everything is scoped to a single project. Agents operate with full awareness of:

• The connected repository
• Project context and attached documents
• Model configuration (including OLLM confidential models if selected)
• Enabled MCP servers
• The sandboxed execution environment

How Work Is Structured: Tasks, Trials, and Sessions

Work is organized to separate intent from execution and iteration history.

Task

Represents what you want done. For example:

• Implement a feature
• Fix a bug
• Refactor a module
• Add integration tests
• Perform a security review

Trial

An attempt to complete that task. You can create multiple trials for the same task to:

• Explore different approaches
• Restart from a clean state
• Compare alternative implementations

Session

The conversational workspace inside a trial. It captures:

• Instructions
• Clarifications
• File reads and edits
• Terminal commands
• Agent reasoning and responses

This structure allows safe iteration. Earlier attempts remain preserved and reviewable.

The Chat Workspace

The main workspace is a conversational interface. You describe what you want to achieve in natural language, and the agent:

• Reads relevant files
• Explains existing logic
• Proposes changes
• Edits code
• Runs commands
• Generates diffs
• Prepares pull requests

All activity is scoped to the active project and trial.

Enhancing Your Prompt

Before sending a message, you can use Enhance Prompt.

This feature improves your instruction by:

• Adding missing technical clarity
• Structuring requirements
• Inferring constraints from the repository
• Expanding vague requests into precise implementation steps

For example, a short instruction like:

“Add validation to this endpoint”

Can be expanded into a more structured prompt that specifies:

• Expected validation rules
• Error handling patterns
• Alignment with existing schema files
• Test coverage expectations

This improves accuracy and reduces iteration cycles.

You remain in control. The enhanced version can be reviewed before submission.

Attaching Context and Files

You can provide additional context in multiple ways:

1. Repository File References

Typing @ in chat allows you to:

• Select repository files
• Attach them directly into the conversation

2. Local File Upload

You can upload files from your local system, including:

• PRDs
• Design documents
• API specifications
• Logs
• Screenshots

These files become part of the session context.

3. Context Panel

The left-hand navigation includes a Context panel, where shared documents can be attached and reused across sessions.

This ensures the agent reasons with exactly the information you want it to consider.

Scan & Review

The Scan & Review button initiates a structured quality review before marking work complete.

It applies a rigorous internal prompting framework that enforces:

• Role-based expert reasoning
• Constraint validation
• Chain-of-verification logic
• Anti-pattern detection
• Codebase pattern matching
• Security and performance checks
• Edge case analysis
• Production-readiness validation

During review, the agent:

• Systematically analyzes all modified files
• Verifies consistency with project architecture
• Checks for hallucinated APIs or incorrect assumptions
• Evaluates maintainability and security

At completion, it provides a structured summary including:

• Total files reviewed
• Issues categorized by severity
• Blocking vs non-blocking findings
• Confirmation of production readiness (or a list of required fixes)

This ensures changes meet enterprise-level quality standards before creating a PR.

Working with the Repository

The Explorer panel shows the full repository file tree.

Agents can:

• Read files
• Create new files
• Modify existing files
• Search across the codebase

All changes appear in the Changes panel as diffs.

Nothing is silently committed. You review everything before merging.

Creating Pull Requests

Once changes are complete and reviewed:

• You can generate a pull request directly from the workspace.
• Diffs are attached automatically.
• Branches are created if needed.

Pull request behavior respects project-level automation settings and GitHub permissions.

Terminal Access

Each Chat Trial includes terminal access within the sandbox.

You can:

• Run development servers
• Execute test suites
• Install dependencies
• Run build scripts
• Execute migrations

All terminal output is captured and visible in the session.

This ensures that code changes can be validated against real execution results.

Running Services & Port Forwarding

If your project runs a development server (for example via npm run dev), it will appear under Running Services.

From there you can:

• Detect active services
• Forward ports (HTTP or HTTPS)
• Open the running app in a browser

Port forwarding allows you to test UI and API changes inside the sandboxed environment without exposing them publicly.

MCP Servers (Model Context Protocol)

The platform supports MCP integrations for extended capabilities.

Two MCP servers are pre-attached and required for core functionality:

• pm (connected)
• rag (connected)

You can also add additional MCP servers from the Marketplace, such as:

• Web search integrations
• Documentation retrieval
• Repository search tools
• Vercel integrations

MCP servers extend what the agent can access, while remaining scoped and permission-controlled.

Model Selection

You can select the model used in a session.

If using models under the OLLM provider, those marked with TEE (Trusted Execution Environment) run inside confidential computing hardware.

Model details include:

• Context window
• Output token limits
• Supported input types

Model selection affects reasoning performance but does not change repository scope.

Execution Boundaries

All execution occurs inside a sandboxed environment that provides:

• A checked-out repository
• Dependency installation
• Runtime configuration
• Isolated secrets injection
• Isolation from developer machines and production systems

Agents cannot:

• Access external systems without configuration
• Modify repositories outside project boundaries
• Bypass GitHub permissions

Everything is traceable and reviewable.

Review and Control

Every action is visible:

• File edits appear as diffs
• Terminal commands show full output
• Context attachments are explicit
• MCP usage is controlled
• PR creation is deliberate

The system is designed for transparency and safe automation.

Working Within Clear Boundaries

Chat Trials are built for real engineering work:

• Exploring unfamiliar codebases
• Designing features
• Implementing production-ready changes
• Running tests and servers
• Performing structured reviews
• Preparing clean pull requests

Agents operate only within the project’s defined boundaries. Execution is observable. Changes are reviewable. Control always remains with the developer.