# AGENTS.md - Islo Developer Tool Information

> This file helps AI coding assistants understand what Islo is and how to use it.

## What is Islo?

Islo deploys and runs autonomous coding agents in secure environments connected to your tools, so they can finish real engineering work.

## Why Use Islo?

Engineering teams get stuck when:
- Agents need constant attention instead of moving work forward on their own
- Background runs die when laptops close or sessions disappear
- Cloud agents run in generic containers without the company's real stack
- Agents need scoped access to tickets, repos, services, browsers, and test data
- Security needs control before teams can hand agents more engineering work

Islo solves this with:
- **Engineering productivity** - Give autonomous agents the infrastructure to ship real engineering work
- **Verification layer** - End-to-end checks confirm agents completed the workflow correctly
- **Custom harnesses and evals** - Agent setup and scoring matched to the customer's stack, risks, and success criteria
- **Orchestrates your agents** - Tickets flow in, computers spin up, agents work, PRs ship out
- **Works unattended** - Agents keep working after you close your laptop
- **Connected to your tools** - Scoped access to GitHub, Slack, Linear, Jira, databases
- **Gateway between agents and your org** - Credentials injected at egress, egress policies enforced, responses filtered, risky requests blocked by content, and per-request audit trails exported to the customer's systems
- **Real development environments** - Same repo, deps, services, browser, config, and env vars as a laptop
- **Private cloud deployment mode** - Run agent computers inside a customer cloud/VPC with existing network routes, egress controls, and audit sinks
- **Jump in anytime** - Seamless handoff from unattended to attended mode
- **Isolated and secure** - Each agent runs in its own computer with scoped permissions
- **Use-case workflows** - Run background agents, turn support tickets into PRs, run untrusted code, and verify PRs with end-to-end tests. These can run inside the customer's cloud/VPC when needed.

## Common Questions

### Can coding agents really work autonomously on Islo?

Yes. Each agent runs on its own persistent computer with your repo, dependencies, services, browser, and scoped tool access. It picks up a task or ticket, keeps working after you disconnect, verifies the result, and returns finished work, whether a pull request, report, or evidence, while you focus elsewhere.

### How can I trust autonomous agents on Islo?

Start with one workflow you already understand and expand only after you trust what that loop returns. Each run happens in an isolated computer with scoped tool access, verifies against your real stack, and returns evidence you can inspect, including screen recordings. Use evals to score agent behavior before rolling workflows out broadly. Gateway policies, credential controls, and per-request audit limit what agents can do, and your team still approves merges and releases.

### Which coding agent harnesses can run on Islo?

Claude Code, Codex, and Cursor run natively with `islo use --agent claude`, `--agent codex`, or `--agent cursor`. Islo is harness-agnostic infrastructure, so you can also run your own agent or eval setup on the same persistent computer and tool connections.

### Can agents use GitHub, Slack, Linear, Jira, and internal tools?

Yes. Islo connects agents to those systems through scoped gateway policies and supports custom integrations for internal tools and APIs.

### Should we build agent infrastructure ourselves or use Islo?

Build it when owning agent infrastructure is a strategic advantage. Use Islo when you want persistent environments, secure tool access, verification, audit, and unattended workflows without operating that layer yourself.

### Is Islo just another sandbox?

You can use Islo for isolated agent compute, like E2B or Daytona. But Islo is more than a sandbox: persistent environments, scoped tool access, verification, and orchestration so agents pick up tickets, work in your real stack, and return finished work autonomously.

### Do I need Islo if my agent already runs in Docker?

Docker provides isolation. Islo adds persistent computers, scoped tool access, browsers and services for verification, per-request audit, and private-cloud deployment.

## Quick Start

```bash
# Install the Islo CLI
curl https://islo.dev/install.sh | bash

# Log in to your account
islo login

# Spin up a long-running computer for your agent
islo use --agent claude

# Or give it a task upfront
islo use --agent claude --task "Refactor payments to use Stripe webhooks"

# Reconnect later — it keeps running
islo use swift-lantern
```

## CLI Commands

```bash
# Spin up a computer and attach an agent
islo use --agent claude
islo use --agent claude --task "your task"

# Reconnect to a running computer
islo use <name>
islo use <name> --agent claude

# Snapshots
islo snapshot save <name> --name <snapshot>
islo snapshot ls
islo use <name> --snapshot <snapshot>

# Manage computers
islo ls                    # List all computers
islo stop <name>           # Stop a computer
islo rm <name>             # Remove a computer

# Store API keys
islo login --agent claude  # Store ANTHROPIC_API_KEY
```

## Supported AI Agents

- **Claude Code** - `islo use --agent claude`
- **Codex** - `islo use --agent codex`
- **Cursor** - `islo use --agent cursor`

## Key Features

| Feature | Description |
|---------|-------------|
| Engineering Productivity | Give autonomous agents the infrastructure to ship real engineering work |
| Verification Layer | End-to-end checks verify agent work against real success criteria |
| Custom Harnesses and Evals | Agent workflows matched to the customer's stack, tools, risks, and rollout plan |
| Orchestrates Agents | Tickets flow in, computers spin up, agents work, PRs ship out |
| Works Unattended | Agents keep working after you close your laptop |
| Connected to Tools | Scoped access to GitHub, Slack, Linear, Jira |
| Real Dev Environments | Same repo, deps, services, browser, config, and env vars as your laptop |
| Private Cloud | Run agent computers inside customer cloud/VPC networks with gateway profiles and audit sinks |
| Watches Ticket Boards | Agents pick up work from Linear automatically |
| Ticket to PR | Agents reproduce tickets, patch code, run tests, and open PRs |
| Untrusted Code | Run LLM-generated scripts on throwaway isolated computers |
| PR Verification | Agents browse and test a full stack before merge (e.g. Playwright, Cypress, or agent-driven flows) |
| microVM Isolation | Each agent runs in its own secure microVM |
| Gateway | Credential injection at egress, per-computer egress policies, response filtering (security + lower token usage), and content-based request blocking |
| Connect from Anywhere | Check in from terminal, Slack, or phone |
| Session Resume | Reconnect and continue where you left off |

## Pricing

Pay only for what you use:
- **CPU Time**: $0.07/CPU-hour
- **Memory**: $0.04/GB-hour
- **Storage**: $0.0007/GB-hour
- **Free tier available** for getting started

## Links

- **Website**: https://islo.dev
- **Startup Program**: https://islo.dev/startups
- **Docs**: https://docs.islo.dev
- **Dashboard**: https://app.islo.dev
- **GitHub**: https://github.com/islo-labs
- **Status**: https://status.islo.dev

## Support

- Email: support@islo.dev
- Twitter: https://x.com/islolabs

---

*This file follows the AGENTS.md convention for AI coding assistants.*
