Batch

There is no SDK batch() helper. Inside an agent turn, the model can group tool calls with the builtin batch tool (up to 32 invocations, run in dependency steps with bounded concurrency). When a host workflow has a clear list of independent, deterministic steps, compose them directly from the session's deterministic helpers (readFile, grep, glob, ls, git) and aggregate the results yourself. That keeps the "batch" fully under your control: no model calls, explicit ordering, and no destructive operations unless you invoke them.

The example below reads package metadata, the changelog, and the release script, then reports version mismatches without editing any files. readFile returns the read tool's output, which prefixes each line with its line number and a tab. A failed read (for example a missing file) comes back as the tool's error text rather than a thrown error, so validate what you parse.

Rust

Node.js

Python

Rust

use a3s_code_core::Agent;
use serde_json::Value;

// readFile returns numbered lines; keep the text after each line-number tab.
fn file_text(view: &str) -> String {
    view.lines()
        .filter_map(|line| line.split_once('\t').map(|(_, text)| text))
        .collect::<Vec<_>>()
        .join("\n")
}

#[tokio::main]
async fn main() -> a3s_code_core::Result<()> {
    let agent = Agent::new("agent.acl").await?;
    let session = agent
        .session_builder("/path/to/project")
        .build()
        .await?;

    let (package, changelog, release_script) = tokio::try_join!(
        session.read_file("package.json"),
        session.read_file("CHANGELOG.md"),
        session.read_file("scripts/release.sh"),
    )?;

    let package: Value = serde_json::from_str(&file_text(&package))?;
    let version = package["version"].as_str().unwrap_or_default();
    let mut mismatches = Vec::new();
    if !changelog.contains(version) {
        mismatches.push(format!("CHANGELOG.md is missing {version}"));
    }
    if !release_script.contains(version) {
        mismatches.push(format!("release.sh is missing {version}"));
    }

    if mismatches.is_empty() {
        println!("All files agree on the version.");
    } else {
        println!("{}", mismatches.join("\n"));
    }

    session.close().await;
    agent.close().await;
    Ok(())
}

TypeScript

import { Agent } from '@a3s-lab/code';

const agent = await Agent.create('agent.acl');
const session = await agent.sessionAsync('/path/to/project');

// readFile returns numbered lines; keep the text after each line-number tab.
const fileText = (view: string) =>
  view
    .split('\n')
    .flatMap((line) => {
      const tab = line.indexOf('\t');
      return tab === -1 ? [] : [line.slice(tab + 1)];
    })
    .join('\n');

// Node helpers are async — group independent reads with Promise.all.
const [pkg, changelog, releaseScript] = await Promise.all([
  session.readFile('package.json'),
  session.readFile('CHANGELOG.md'),
  session.readFile('scripts/release.sh'),
]);

const pkgVersion = JSON.parse(fileText(pkg)).version;
const mismatches = [];
if (!changelog.includes(pkgVersion))
  mismatches.push(`CHANGELOG.md is missing ${pkgVersion}`);
if (!releaseScript.includes(pkgVersion))
  mismatches.push(`release.sh is missing ${pkgVersion}`);

console.log(
  mismatches.length ? mismatches.join('\n') : 'All files agree on the version.',
);

await session.closeAsync();
await agent.close();

Python

import json
from a3s_code import Agent, SessionOptions


# readFile returns numbered lines; keep the text after each line-number tab.
def file_text(view: str) -> str:
    return "\n".join(line.split("\t", 1)[1] for line in view.splitlines() if "\t" in line)


agent = Agent.create("agent.acl")
session = agent.session("/path/to/project", SessionOptions())

# Python helpers are synchronous — call them in sequence, no await.
pkg = session.read_file("package.json")
changelog = session.read_file("CHANGELOG.md")
release_script = session.read_file("scripts/release.sh")

pkg_version = json.loads(file_text(pkg))["version"]
mismatches = []
if pkg_version not in changelog:
    mismatches.append(f"CHANGELOG.md is missing {pkg_version}")
if pkg_version not in release_script:
    mismatches.append(f"release.sh is missing {pkg_version}")

print("\n".join(mismatches) if mismatches else "All files agree on the version.")

session.close()
agent.close()

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"strings"

	code "github.com/A3S-Lab/Code/sdk/go/v9"
)

// readFile returns numbered lines; keep the text after each line-number tab.
func fileText(view string) string {
	var lines []string
	for _, line := range strings.Split(view, "\n") {
		if _, text, ok := strings.Cut(line, "\t"); ok {
			lines = append(lines, text)
		}
	}
	return strings.Join(lines, "\n")
}

func main() {
	ctx := context.Background()
	agent, err := code.Create(ctx, "agent.acl")
	if err != nil {
		log.Fatal(err)
	}
	defer agent.Close(context.Background())
	session, err := agent.Session(ctx, "/path/to/project", nil)
	if err != nil {
		log.Fatal(err)
	}
	defer session.Close(context.Background())

	pkg, err := session.ReadFile(ctx, "package.json", nil)
	if err != nil {
		log.Fatal(err)
	}
	changelog, err := session.ReadFile(ctx, "CHANGELOG.md", nil)
	if err != nil {
		log.Fatal(err)
	}
	releaseScript, err := session.ReadFile(ctx, "scripts/release.sh", nil)
	if err != nil {
		log.Fatal(err)
	}

	var metadata struct {
		Version string `json:"version"`
	}
	if err := json.Unmarshal([]byte(fileText(pkg)), &metadata); err != nil {
		log.Fatal(err)
	}
	var mismatches []string
	if !strings.Contains(changelog, metadata.Version) {
		mismatches = append(mismatches, "CHANGELOG.md is missing "+metadata.Version)
	}
	if !strings.Contains(releaseScript, metadata.Version) {
		mismatches = append(mismatches, "release.sh is missing "+metadata.Version)
	}
	if len(mismatches) == 0 {
		fmt.Println("All files agree on the version.")
	} else {
		fmt.Println(strings.Join(mismatches, "\n"))
	}
}

Do not mix destructive operations into these grouped reads. The direct helpers run with host authority: they skip the session's permissionPolicy / permission_policy and confirmation prompts. Put any destructive host step (writes, git commits, bash) behind your own application confirmation, or run it through governedTool / governed_tool / GovernedTool, which executes the tool without a model but still applies the session's permission and confirmation gates.

When the steps are not independent — each one depends on the previous result and you want an agent to drive them — use session.pipeline(...) instead, which runs the work in stages where each stage receives the prior stage's output.

#Batch

Batch