Run Agent Harnesses in the Cloud

Invoke Claude Code, Codex, and OpenCode via API, CLI, or UI. Run them in isolated sandboxes with persistent filesystems, parallel worktrees, and Git-native version control.

Start building View docs

Star View contributor guide.

Start with a few lines of code.

Choose a project, harness, and model.
Give it a task. Let it work.

Read the API quickstart

import { Macrofold } from 'macrofold';const macrofold = new Macrofold();const run = await macrofold.runs.create({  project_id,  harness: 'codex',  model: 'gpt-5.4-mini',  billing_mode: 'managed',  prompt: 'Build a working prototype.',});for await (const text of macrofold.runs.streamText(run.run_id)) {  process.stdout.write(text);}

Set up your first run

Create a project in the dashboard and set project_id and MACROFOLD_API_KEY. Choose a compatible model from the catalog: this example uses OpenAI’s GPT-5.4 mini with Codex. The catalog determines the provider. Managed execution uses your credits; no saved session or agent preset is required.

Follow the SDK installation guide. Go is a function body with ctx, projectID, fmt, and the SDK import. Rust runs in an async function with a parsed project UUID. Install the Macrofold CLI, then log in and link a project.

cURL uses jq to read the run ID. Keep the request key and body to recover an interrupted response. SDKs handle idempotency and stream reconnection. Complete API quickstart →

The conversation changes.
Their information stays.

Give every customer a persistent agent—with its own files, tools, and ongoing work. Let different agents build on those files over time.

Alice’s project files

One customer. One lasting source of context.profile.mdmemory/travel.mdtasks.json

Optional starter layout · ordinary, editable files

Monday: meet Milo
Alice shares her preferences with her personal agent.
Tuesday: bring in a specialist
A research agent reads the saved brief in a fresh conversation.
Friday: follow up on schedule
Milo uses the latest files to prepare Alice’s weekly plan.
weekly-plan.md updated
Alice opens the result and corrects a preference for next time.

Customer agents is an optional integration path over Macrofold’s projects, worktrees, presets and runs. Your app owns customer identity. This illustrative workflow uses ordinary files and separate conversations; the optional memory starter guides what agents save.

Build this customer experience

An entire agent harness
as one unit of execution.

Everything agents can do on your computer available in your product or internal tool, with thousands of available app connectors.

Example use cases:

Project

Give every customer a working context.

Put an agent inside your product, with a project that holds each customer’s knowledge. It reads their context before it gets to work.

Explore this feature

Worktrees

More tasks. Room for each one.

Draft outreach, review feedback, and update a brief in parallel. Each agent gets its own worktree, so concurrent tasks can work independently.

Explore this feature

Checkpoints and Git Sync

Keep the work. Build on it.

Persist files between runs with verified checkpoints. Review changes and merge them back into the project; sync your branches with GitHub when you’re ready.

Explore this feature

API, CLI, UI

Part of your product. Within your reach.

Your application starts the work through the API. Step in from the CLI or dashboard to give another instruction and follow the result.

Explore this feature

Connectors

Let context come from your tools.

Connect the customer’s CRM, email, and knowledge sources. Choose which connections and tools each task can access.

Explore all connectors

Project

Give every customer a working context.

Put an agent inside your product, with a project that holds each customer’s knowledge. It reads their context before it gets to work.

Explore this feature

main

API

Write a cold sales email to Alex at Northstar. Refer to enterprise pitch guidance.

Codex

product_info.mdpitch_guidance.mdbrand_voice.mdcustomers/meetings/

API

What did Sam say on our last feedback call?

Claude Code

product_info.mdpitch_guidance.mdbrand_voice.mdcustomers/meetings/

CLI

Update our sales brief with this week’s customer insights.

OpenCode

product_info.mdpitch_guidance.mdbrand_voice.mdcustomers/meetings/

Make the email warmer and more concise.

Codex

product_info.mdpitch_guidance.mdbrand_voice.mdcustomers/meetings/

Per-Customer Agent Workspaces

Write a cold sales email to Alex at Northstar. Refer to enterprise pitch guidance.

Give every customer a working context.

Put an agent inside your product, with a project that holds each customer’s knowledge. It reads their context before it gets to work.

More tasks. Room for each one.

Draft outreach, review feedback, and update a brief in parallel. Each agent gets its own worktree, so concurrent tasks can work independently.

Keep the work. Build on it.

Persist files between runs with verified checkpoints. Review changes and merge them back into the project; sync your branches with GitHub when you’re ready.

Part of your product. Within your reach.

Your application starts the work through the API. Step in from the CLI or dashboard to give another instruction and follow the result.

Let context come from your tools.

Connect the customer’s CRM, email, and knowledge sources. Choose which connections and tools each task can access.

Self-improving Agents

Run a simulation. Use the results to improve the strategy.

An agent with something to learn from.

Keep the strategy, evaluation criteria, and previous results in a persistent project. Each simulation starts with the context of earlier work.

Explore the alternatives in parallel.

Give each experiment a separate worktree. Agents can test different approaches without overwriting one another’s working files.

Make improvement inspectable.

Save the results and strategy changes as checkpoints. Compare versions, review the evidence, and merge the changes you want to keep.

Close the loop from your application.

Start the next evaluation through the API, investigate from the terminal, or review the strategy in the dashboard. You define the criteria and the next step.

Bring evidence into the loop.

Give the agent access to your data, research, and monitoring tools. Select the tools it needs to evaluate a strategy and record the outcome.

Shared Team Agents

Help debug the checkout issue reported in our team channel.

A shared place to understand the work.

Give a team agent your product repository, runbooks, and meeting context. A debugging request arrives with somewhere useful to begin.

Investigate from more than one angle.

Run separate investigations in parallel worktrees. One agent traces the code while others review customer feedback and recent changes.

Turn an investigation into a reviewable change.

Keep the investigation and its files. Verified checkpoints preserve progress; Git branches let your team review and merge the fix through its usual workflow.

Meet the team where it works.

Your incident service invokes an agent through the API. A developer follows up from the CLI, while a teammate reviews the work in the dashboard.

Connect the evidence, not just the code.

Bring together issue tracking, team conversations, logs, and monitoring. Add scoped database access through custom MCP when the investigation needs it.

Personal Agent

Find me a new restaurant I'd like, for 2 at 6pm tonight.

A little less explaining, every time.

Keep preferences, past plans, and useful notes in one project. Your personal agent can read what matters before finding somewhere new.

Give every idea its own space.

Explore dinner, nearby activities, and alternatives in separate worktrees. Each agent has the same starting context and its own task.

Remember the things worth keeping.

Save recommendations and updated preferences across runs. Checkpoints let you revisit earlier versions; optional Git sync gives your project a repository home.

One agent environment. Your choice of interface.

Invoke it from an application, send a quick terminal request, or open the dashboard to review the plan. Your project stays in the cloud.

Open up the possibilities.

Connect selected personal apps, web search, and custom tools. Your agent can use the sources you authorize to build a more useful answer.

Everything you need to go live.

BYOK or Use Credits

Bring your own model keys or use managed credits. Pay for the compute you use, with model, storage, and tool charges based on your setup.

Explore pricing

Start at the right moment.

Trigger an agent from a Slack message, a webhook, or a recurring schedule. Connect an agent preset to a project and let the work begin.

Set up a trigger

Pick up where you left off.

Continue a compatible native session with its conversation and project files. Give another instruction without rebuilding the context from scratch.

Explore sessions

See the work as it happens.

Stream progress and tool activity into your product. Follow live output, inspect results, and replay the run’s recorded events later.

Explore streaming

Scope access to the task.

Choose the projects, connections, and tools an agent can use. Scoped grants and server-side authorization keep access tied to the task.

Control access

A boundary around every run.

Execute agents in isolated sandboxes. Infrastructure credentials stay outside agent processes, and stored provider keys and published checkpoints are encrypted.

Understand the platform

The agents you trust.
The tools you need.

Native harnesses, model providers, and the tools your work depends on.

Explore all connectors

Let’s build.

Give your next idea a place to run.

Start building View docs

Contribute to open source Self-host

Run Agent Harnesses in the Cloud

Start with a few lines of code.

The conversation changes.Their information stays.

Alice’s project files

Monday: meet Milo

Tuesday: bring in a specialist

Friday: follow up on schedule

weekly-plan.md updated

An entire agent harnessas one unit of execution.

Give every customer a working context.

More tasks. Room for each one.

Keep the work. Build on it.

Part of your product. Within your reach.

Let context come from your tools.

Give every customer a working context.

Everything you need to go live.

BYOK or Use Credits

Start at the right moment.

Pick up where you left off.

See the work as it happens.

Scope access to the task.

A boundary around every run.

The agents you trust.The tools you need.

Agent harnesses

Model providers

Tools

Search and web

Version control

Let’s build.

The conversation changes.
Their information stays.

An entire agent harness
as one unit of execution.

The agents you trust.
The tools you need.