.NET

dotnet add package Simular.Sai
export SAI_API_KEY="sapi_..."

using Simular.Sai;

var sai = new SaiClient();
var pc = (await sai.Machines.ListAsync())[0];

var session = await sai.Sessions.CreateAsync(machine: pc);
var result = await session.RunAsync("Open Notepad, type hello, save it to the desktop as hello.txt");

Console.WriteLine(result.Status); // idle, needs_approval or error
Console.WriteLine(result.Text); // Sai's answer
Console.WriteLine(result.Usage); // tokens and cost of this task

var turn = await session.SendAsync("Find last month's invoices in Downloads and total them");
await foreach (var ev in turn.EventsAsync())
{
    if (ev.Kind == EventKind.Step) Console.WriteLine($"   {ev.Text}");
    else if (ev.Kind == EventKind.Approval) await turn.RespondAsync(ev.Approval!, "yes");
}
var answer = await turn.WaitAsync();

var cleaned = await session.RunAsync("Clean up the temp folder", new RunOptions
{
    OnApproval = approval =>
    {
        if (approval.IsLinkOnly)
        {
            Console.WriteLine($"Approve in a browser: {approval.Url}");
            return null; // a person answers it; keep waiting
        }
        if (approval.Type == "choice")
        {
            var selections = approval.Questions
                .Select(q => new[] { q.GetProperty("options")[0].GetProperty("value").GetString()! })
                .ToArray();
            return new ApprovalAnswer("yes", selections);
        }
        return "yes";
    },
});

await session.RunAsync("Export last month's invoices to CSV", new RunOptions { Autonomous = true });

var report = await sai.Files.UploadAsync("report.pdf"); // or UploadAsync(bytes, "report.pdf")
await session.RunAsync("Summarise the attached report", new RunOptions { Attachments = [report] });

var allowed = (await sai.Models.ListAsync()).Where(m => m.Allowed).Select(m => m.Id).ToList();
await session.RunAsync("...", new RunOptions { Model = "anthropic/claude-opus-5-5" }); // sticks to the session

var turn = await session.SendAsync("...");
await turn.AbortAsync();

var typed = await session.RunAsync(
    "Open https://news.ycombinator.com and read the title of the top story.",
    new RunOptions
    {
        OutputSchema = new
        {
            type = "object",
            properties = new { title = new { type = "string" } },
            required = new[] { "title" },
        },
    });
if (typed.Ok) Console.WriteLine(typed.Record?.Output?.GetProperty("title").GetString());
else Console.WriteLine(typed.Record?.ReasonCode); // e.g. output_invalid

var turn = await session.SendAsync("...", new SendOptions { RecordTrajectory = true });
var record = await sai.Turns.WaitAsync(turn); // until succeeded, failed or needs_input
foreach (var step in await sai.Turns.TrajectoryAsync(turn))
{
    Console.WriteLine($"{step.Index} {step.Title}");
}

var turn = await session.SendAsync(
    "Open {{newsSite}}, find all {{topic}} news published today, write their headlines into Notepad, one per line, and save the file as {{fileName}}",
    new SendOptions
    {
        Inputs = new Dictionary<string, object> { ["newsSite"] = "TechCrunch", ["topic"] = "AI", ["fileName"] = "techcrunch_headlines.txt" },
        RecordTrajectory = true,
    });
await sai.Turns.WaitAsync(turn);

var learned = await sai.Learn.CreateAsync([turn]); // waits for the code; longer for a longer task
var fintech = new Dictionary<string, object> { ["newsSite"] = "TechCrunch", ["topic"] = "Fintech", ["fileName"] = "techcrunch_fintech.txt" };
var lease = await sai.Control.OpenAsync(pc);
var r = await lease.RunAsync(learned, fintech); // inputs over the defaults
Console.WriteLine(r.Result);
await lease.CloseAsync();

var repaired = await sai.Learn.CreateAsync([], new LearnOptions
{
    InitialCode = learned.Code,
    Evaluations = [new Evaluation(fintech, r, Passed: false)],
});
var judgement = await sai.Judge.CreateAsync(
    [turn],
    new[] { new Check("file", "The agent saved the headlines to the file") });

var job = await sai.Learn.CreateAsync([], new LearnOptions
{
    TaskTemplate =
        "Open {{newsSite}}, find all {{topic}} news published today, write their headlines into Notepad, one per line, and save the file as {{fileName}}",
    Inputs = new Dictionary<string, object> { ["newsSite"] = "TechCrunch", ["topic"] = "AI", ["fileName"] = "techcrunch_headlines.txt" },
    Machine = pc,
    Criteria =
        "techcrunch_headlines.txt is saved and holds, one per line, the headlines of the AI articles TechCrunch published today",
    MaxIterations = 3, // up to 3 code versions; 0 (the default) only writes the code
    Rollouts = 3, // each version must pass 3 runs in a row
    Reset = Reset.Code("""
        for (const t of await machine.browser.listTabs()) await machine.browser.closeTab(t.tabId)
        for (const w of await machine.getWindow("Notepad")) await w.close()
        """),
    ContinueWithAgent = true, // after a failed run, the agent finishes the task and the repair learns from it
});
var done = await sai.Learn.WaitAsync(job); // can take an hour; pass timeout: to stop waiting
Console.WriteLine($"{done.Status} {done.StopReason} {done.TestResult}");
Console.WriteLine(done.Code); // the latest version
foreach (var it in done.Iterations)
{
    Console.WriteLine($"{it.Index} {it.Changes} {string.Join(", ", it.Rollouts.Select(x => x.Verdict))}");
}

var run = await sai.Learn.RolloutAsync(job, 1, 1); // what one run returned and logged, and its judgement
await sai.Learn.CancelAsync(job); // stops at once and keeps the last complete results

await using (var lease = await sai.Control.OpenAsync(pc))
{
    Console.WriteLine((await lease.ShellAsync("hostname")).Stdout);

    await lease.WriteFileAsync(@"C:\data\note.txt", "hello");
    Console.WriteLine(await lease.ReadFileAsync(@"C:\data\note.txt"));

    var r = await lease.ExecAsync("""
        var page = await machine.browser.newtab('https://example.com')
        var snap = await page.snapshot()
        snap.title
        """);
    Console.WriteLine(r.Result); // Example Domain
    await File.WriteAllBytesAsync($"page.{r.ScreenshotMimeType!.Split('/')[1]}", r.Screenshot!); // jpeg or png
}

await sai.Account.GetAsync(); // plan and spendable credit
await sai.Models.ListAsync(); // models, with Allowed for this plan
await sai.Machines.LiveAsync(pc); // a link to the screen for a person, and a stream for your viewer; see Live view
await sai.Machines.RevokeLiveAsync(pc); // every LiveUrl stops working and its screen sessions end; returns how many

await sai.Auth.CheckAsync(); // the user, and the Tenant and Organisation for a Tenant token
await sai.Sessions.ListAsync(machine: pc); // your sessions on the computer, any channel, most recent first

var view = await sai.Machines.LiveAsync(pc);
Console.WriteLine($"Sign in here, then tell me: {view.LiveUrl}"); // valid until view.ExpiresAt (ms)
// ... once they are done
await session.RunAsync("I signed in. Carry on.");
await sai.Machines.RevokeLiveAsync(pc); // returns the number of links revoked

using Simular.Sai;

var org = new SaiClient(new SaiClientOptions
{
    ApiKey = Environment.GetEnvironmentVariable("SAI_ORG_KEY"),
    OrgId = "org_3f9a1c0b7e2d4a6f8c10",
});

var tenant = await org.Tenants.CreateAsync("Riverside Clinic", externalId: "clinic-4821");
var enrollment = await org.Tenants.CreateEnrollmentAsync(tenant); // hand enrollment.Token to your installer
Console.WriteLine(string.Join(", ", await org.TenantMachines.ListAsync(tenant)));

var clinic = await org.Tenants.ClientAsync(tenant); // acts as the Tenant
var visit = await clinic.Sessions.CreateAsync();
await visit.RunAsync("Open the calendar and read today's appointments");

using Simular.Sai;

var org = new SaiClient(new SaiClientOptions
{
    ApiKey = Environment.GetEnvironmentVariable("SAI_ORG_KEY"),
    OrgId = "org_3f9a1c0b7e2d4a6f8c10",
});

var machine = await org.TenantMachines.CreateAsync(
    "Xk2p9QzR4tLm8vNa3bCd",
    os: "windows",
    name: "Riverside intake",
    requestId: Guid.NewGuid().ToString(),
    wait: true);
var clinic = await org.Tenants.ClientAsync("Xk2p9QzR4tLm8vNa3bCd");
var visit = await clinic.Sessions.CreateAsync(machine: machine.Id);
await visit.RunAsync("Open Notepad and type hello");
await org.TenantMachines.DeleteAsync("Xk2p9QzR4tLm8vNa3bCd", machine);

using Simular.Sai;

var org = new SaiClient(new SaiClientOptions
{
    ApiKey = Environment.GetEnvironmentVariable("SAI_ORG_KEY"),
    OrgId = "org_3f9a1c0b7e2d4a6f8c10",
});
var usage = await org.Usage.GetAsync(granularity: "month", from: "2026-10", to: "2026-10");
foreach (var t in usage.Totals.ByTenant.Values) Console.WriteLine($"{t.Name} {t.CostCents}");

var page = await org.Usage.SessionsAsync("Xk2p9QzR4tLm8vNa3bCd", from: "2026-10-01", to: "2026-10-31");
foreach (var s in page.Sessions) Console.WriteLine($"{s.SessionId} {s.CostUsd}");