Introducing NexaBatch: The Local-First AI Batch Engine

Every digital worker, developer, and content creator faces the same repetitive, soul-crushing friction: taking dozens or hundreds of files and converting, resizing, redacting, reformatting, or restructuring them. You might have 120 camera RAW files that need GPS metadata removed, dimension scaling down to 1920px wide, and conversion to WebP at 85% compression before being bundled into a client ZIP archive. Or perhaps you have twenty scanned PDF invoices requiring watermarking, page merging, and secure AES-256 encryption before email dispatch.

Until now, your choices for solving batch tasks have been polarized between two equally flawed extremes: paying monthly subscriptions to centralized cloud SaaS converters that upload your proprietary files to remote servers, or writing bespoke terminal scripts requiring local Python environments, FFmpeg binaries, and ImageMagick dependencies.

Today, we are launching NexaBatch — a brand-new, local-first batch file processing suite integrated directly into NexaTools. NexaBatch combines the reasoning intelligence of Google's Gemini 3.6 Flash model with high-performance in-browser WebAssembly and HTML5 APIs. With NexaBatch, you simply describe what you want done in plain English, drop your files into the browser, and watch an automated pipeline execute across your CPU and GPU without a single byte of your file content ever leaving your machine.

The Broken State of Batch Processing in 2026§

To understand why NexaBatch represents a fundamental architectural shift, consider how batch processing has historically operated on the web.

Traditional Cloud Batch Architecture:
[User Device] ──(Gigabytes of Raw Uploads)──> [Remote Cloud Server]
                                                    │
                                            (Temp Disk Storage)
                                                    │
                                            (Server Queue / EC2)
                                                    │
[User Device] <──(Gigabytes of Raw Downloads)── [Cloud Zip Export]

When you drag 200MB of marketing graphics or confidential legal documents into a conventional cloud converter, several points of failure occur:

1. Massive Bandwidth Latency: Every single byte must travel over your upstream internet connection to a remote data center. For high-resolution media or multi-gigabyte video clips, upload times alone dominate the entire workflow.
2. Privacy and Surveillance Risks: Centralized cloud tools ingest your raw binary data into server-side ephemeral storage or AWS S3 buckets. Even when providers guarantee file deletion within 24 hours, your data is exposed to server-side memory dumps, supply-chain vulnerabilities, and lawful intercept requests.
3. Artificial SaaS Paywalls: Traditional providers enforce aggressive monetization models. You are hit with 100MB file caps, daily conversion quotas, artificial throttling, and requests to upgrade to a $25-to-$50-per-month enterprise tier just to convert more than three files simultaneously.
4. Rigid Interface Silos: If your task spans multiple categories — such as extracting audio from video files, converting that audio to MP3, and renaming the files based on a spreadsheet — cloud tools force you to jump across three separate websites, downloading and re-uploading intermediate artifacts at each step.

Alternatively, power users turn to the command line:

# Typical command-line multi-step batch script
mkdir -p ./output
for f in *.jpg; do
  exiftool -all= "$f" -out "./temp_${f}"
  magick "./temp_${f}" -resize 1920x1080\> -quality 85 "./output/${f%.jpg}.webp"
  rm "./temp_${f}"
done
zip -r final_archive.zip ./output/

While CLI tools are fast and private, they demand developer expertise, shell environment configuration, tool version synchronization, and extensive syntax memorization. Non-technical team members cannot run these scripts, and even experienced developers waste billable hours debugging command flags across Windows PowerShell and Unix bash environments.

NexaBatch eliminates this entire dilemma. It delivers the speed and zero-data privacy of local command-line binaries with the accessibility and visual feedback of a modern web application.

What Is NexaBatch?§

NexaBatch is an agentic, in-browser file workflow orchestrator. It couples an intelligent AI planner with an extensive catalog of over 80 deterministic client-side tool adapters spanning media conversion, document manipulation, text extraction, code transformation, and cryptography.

Instead of navigating complex dropdowns or configuring rigid parameter matrices, you interface with NexaBatch through a unified conversational prompt window paired with an interactive drop zone. You tell the engine:

"Clean all EXIF metadata from these photos, resize them to a maximum width of 1920 pixels, convert them into compressed WebP images, and pack everything into a zip file."

Within milliseconds, NexaBatch inspects the metadata of your dropped files (file extensions, byte counts, and MIME types), queries the Gemini 3.6 Flash planning engine, synthesizes an optimized multi-step Directed Acyclic Graph (DAG), and renders an interactive visual pipeline. You can review the execution plan, customize individual parameters, add or remove steps, and hit Execute Pipeline.

The browser then orchestrates the entire operation in-memory using WebAssembly, WebCodecs, Canvas, and the native Web Crypto API.

Architectural Comparison Matrix§

The table below contrasts NexaBatch against legacy cloud automation platforms and traditional local CLI scripts:

The 3-Step Execution Architecture§

NexaBatch operates through a clean tripartite lifecycle designed to maximize performance while guaranteeing cryptographic data isolation.

┌────────────────────────────────────────────────────────────────────────┐
│                        NEXABATCH EXECUTION FLOW                        │
└────────────────────────────────────────────────────────────────────────┘

 [1. Ingestion & Introspection]
     User drops N files
     Browser reads headers (Magic bytes, MIME, size)
     Files stay in browser memory as File[] objects
                 │
                 ▼
 [2. AI Planning (Gemini 3.6 Flash)]
     System sends: User prompt + file metadata (NO content)
     Gemini returns: Validated JSON execution DAG
     UI renders: Step cards with configurable options
                 │
                 ▼
 [3. In-Memory Pipeline Execution]
     Step 1: Ingests File[] ──────> Emits in-memory Blob[]
     Step 2: Ingests Blob[] ──────> Emits in-memory Blob[]
     Step 3: Ingests Blob[] ──────> Bundles into .ZIP Blob
                 │
                 ▼
 [Download Triggered]
     URL.createObjectURL(zipBlob) ──> Saved to local disk

Step 1: Client-Side Ingestion and Metadata Introspection§

When you drag files into the NexaBatch drop area, the browser initializes standard HTML5 File references. Crucially, the engine does not read the full contents into memory immediately. Instead, it reads only the file headers using an asynchronous slicing operation to inspect the magic bytes:

// High-performance header inspection without loading full file data
async function inspectFileHeaders(file) {
  const slice = file.slice(0, 16);
  const buffer = await slice.arrayBuffer();
  const bytes = new Uint8Array(buffer);
  
  // Extract hex signature (magic numbers)
  const hex = Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
  
  return {
    name: file.name,
    sizeBytes: file.size,
    reportedMime: file.type,
    magicHex: hex
  };
}

This inspection ensures accurate file type identification regardless of whether an input file has an incorrect or missing file extension (such as an MP4 container mistakenly labeled as .dat).

Step 2: Gemini 3.6 Flash Planning Engine§

Once the metadata is compiled, NexaBatch constructs a lightweight prompt payload for Google's Gemini 3.6 Flash model. This is the only outbound network request in the entire workflow. The request payload contains:

1. The user's natural language instruction.
2. A lightweight manifest of the input files (e.g., [{"name": "photo_01.jpg", "size": 3421900, "mime": "image/jpeg"}]).
3. An exact catalog of available NexaBatch tool adapter schemas.

Because Gemini 3.6 Flash boasts ultra-fast token processing times (typically under 600ms for structured schema output) and excellent reasoning over structured API definitions, it instantly maps the user's intent to a linear or branched Directed Acyclic Graph (DAG) serialized as a typed JSON array:

[
  {
    "tool": "exif-strip",
    "label": "Strip EXIF Geolocation & Camera Metadata",
    "options": { "preserveOrientation": true }
  },
  {
    "tool": "image-resize",
    "label": "Scale Images to 1920px Max Width",
    "options": { "maxWidth": 1920, "maintainAspectRatio": true }
  },
  {
    "tool": "image-convert",
    "label": "Convert to WebP Format",
    "options": { "format": "image/webp", "quality": 0.85 }
  },
  {
    "tool": "create-zip",
    "label": "Package Optimized Assets into Zip Archive",
    "options": { "filename": "optimized_assets.zip" }
  }
]

The user is instantly presented with these steps in an interactive UI drawer. If you wish to change the WebP quality from 85% to 92%, or adjust the maximum width to 1280px, you can tweak the inputs directly in the interface without re-prompting the AI.

Step 3: Sequential In-Memory Execution§

When you trigger execution, NexaBatch executes each tool adapter sequentially. The output of Step 1 becomes the direct input for Step 2. All intermediate files exist strictly as ephemeral Blob objects allocated in the browser's JavaScript V8 heap.

// Simplified core loop of the NexaBatch pipeline runner
async function runPipeline(initialFiles, plannedSteps, onProgress) {
  let currentFiles = initialFiles;

  for (let i = 0; i < plannedSteps.length; i++) {
    const step = plannedSteps[i];
    const adapter = NexaBatchRegistry.get(step.tool);

    // Dynamically load external WASM or CDN script dependencies if not already cached
    if (adapter.cdnDeps && adapter.cdnDeps.length > 0) {
      await NexaBatchRegistry.loadDependencies(adapter.cdnDeps);
    }

    onProgress({ stepIndex: i, totalSteps: plannedSteps.length, label: step.label });

    // Execute the adapter entirely in browser RAM
    currentFiles = await adapter.execute(currentFiles, step.options);
  }

  return currentFiles; // Final output array of Blob / File items
}

Because memory pointers are passed directly between adapters, zero disk read/write cycles occur between steps. What previously took minutes of cloud upload and download transfers now processes at the full internal memory bus speed of your computer's RAM.

Real-World Production Workflows§

To demonstrate the versatility of NexaBatch, let us examine three concrete scenarios across media production, document security, and developer data engineering.

Workflow A: E-Commerce Product Photography Optimization§

• The Problem: A creative agency takes 250 high-resolution camera exports (.jpg and .cr2, ~12MB each). Before publishing to Shopify, the images must be stripped of proprietary camera metadata, resized to 1600px width, converted to next-generation AVIF or WebP formats, and renamed with an SEO slug prefix.
• The NexaBatch Prompt:

  "Strip all EXIF data, scale down to 1600px width preserving ratio, convert to WebP at 80% quality, and prefix filenames with 'prod-ss26-'."

• Pipeline Execution:
  1. exif-strip: Parses the JPEG binary markers (APP1 segment), strips out GPS coordinates, camera serial numbers, and creator tags, returning pristine image Blobs.
  2. image-resize: Offloads image decoding to createImageBitmap() and renders pixels across an OffscreenCanvas, computing bilinear interpolation down to 1600px width.
  3. image-convert: Encodes the canvas pixel buffer using browser-native WebP compression.
  4. file-rename: Appends the prod-ss26- slug to each file's metadata object.
  5. create-zip: Compiles all 250 WebP files into a compressed .zip archive using JSZip client-side.
• Result: What previously required a 3GB upload to a cloud service completes locally in 18 seconds, saving bandwidth and preventing client photo leaks.

Workflow B: Legal Redaction, Watermarking, and Contract Bundling§

• The Problem: A legal compliance officer needs to merge 14 counter-signed non-disclosure agreements, stamp each page with a diagonal red "CONFIDENTIAL - STRICTLY RESTRICTED" watermark, and encrypt the combined document using AES-256 with a client-supplied passphrase.
• The NexaBatch Prompt:

  "Merge these PDF agreements, add a diagonal red watermark saying 'CONFIDENTIAL', and encrypt with AES-GCM password protection."

• Pipeline Execution:
  1. pdf-merge: Uses pdf-lib compiled into JavaScript to combine individual PDF document streams, preserving vector text and font definitions without rasterization.
  2. pdf-watermark: Traverses every page dictionary in the PDF AST, injecting a rotated vector text layer with 30% alpha transparency.
  3. file-encrypt: Invokes the browser's native window.crypto.subtle API. It derives a 256-bit symmetric key from the password using PBKDF2 with 100,000 iterations of SHA-256, then encrypts the PDF byte stream using AES-GCM with a random initialization vector (IV).
• Result: Sensitive legal contracts are processed without ever crossing a corporate firewall or external third-party server.

Workflow C: Developer API Data Migration and Integrity Check§

• The Problem: A backend engineer receives 50 database export CSV dumps containing user activity logs. The data must be converted to JSON, formatted with 2-space indentation, stripped of null keys, and verified with a cryptographic SHA-256 checksum for audit logs.
• The NexaBatch Prompt:

  "Convert these CSV files into formatted JSON, remove empty or null values, and generate a SHA-256 hash list for verification."

• Pipeline Execution:
  1. csv-to-json: Streams the raw CSV text, parsing headers and types into structured JavaScript objects.
  2. json-clean: Traverses the object tree recursively, pruning any keys whose values are null, undefined, or empty strings "".
  3. json-format: Serializes the cleansed objects back to text using JSON.stringify(obj, null, 2).
  4. file-hash: Pipes the formatted text buffer through crypto.subtle.digest('SHA-256'), generating an accompanying .sha256 verification checksum file for each dataset.
• Result: Developers can cleanse proprietary production dumps offline on their air-gapped workstations without risking data leaks.

Supported Tool Ecosystem: 80+ Client-Side Adapters§

NexaBatch integrates with the broader NexaTools library, unlocking cross-category functionality that was previously siloed across independent tools. The platform includes adapters across six core functional domains:

┌────────────────────────────────────────────────────────────────────────┐
│                        NEXABATCH TOOL SPECTRUM                         │
├───────────────────┬───────────────────┬────────────────────────────────┤
│ Media & Visual    │ Document & PDF    │ Data & Code Formatting         │
│ • Image Convert   │ • PDF Merge       │ • CSV to JSON / JSON to CSV    │
│ • EXIF Stripper   │ • PDF Split       │ • JSON Minifier & Formatter    │
│ • Image Compress  │ • PDF Watermark   │ • XML to JSON / YAML to JSON   │
│ • Palette Extract │ • PDF Rotate      │ • Base64 Data URI Encoder      │
│ • SVG to PNG/WebP │ • Text Extract    │ • Markdown to HTML Compiler    │
├───────────────────┼───────────────────┼────────────────────────────────┤
│ Audio & Video     │ Cryptography      │ Archive & Packaging            │
│ • Audio Extractor │ • SHA-256 / SHA-1 │ • ZIP Multi-File Packager      │
│ • MP4 to MP3/WAV  │ • MD5 Checksum    │ • TAR / GZIP Extractor         │
│ • Video Trimmer   │ • AES-256-GCM Enc │ • Batch File Renamer           │
│ • Volume Booster  │ • AES-256 Decrypt │ • Chunk Splitter & Joiner      │
└───────────────────┴───────────────────┴────────────────────────────────┘

Every adapter adheres to a standardized micro-contract:

interface NexaBatchAdapter {
  id: string;
  name: string;
  category: 'media' | 'pdf' | 'data' | 'audio' | 'crypto' | 'utility';
  acceptedTypes: string[]; // MIME types or wildcard categories
  outputType: string;
  cdnDeps?: string[];      // Dynamically loaded script URLs
  execute: (files: File[], options: Record<string, any>) => Promise<File[]>;
}

Because each tool adapter shares this uniform input/output contract, tools can be composed in arbitrary sequences. You can convert a CSV to JSON, feed that JSON into a Base64 encoder, compress the result, and encrypt it, all in a single fluid motion.

Benchmarks: In-Browser WASM vs. Cloud Microservices§

To evaluate the real-world efficiency of NexaBatch, we benchmarked an identical batch task across three environments:

• Task: Process 50 smartphone photos (JPEG format, 4032×3024 resolution, averaging 4.2MB each; total batch size: 210MB).
• Pipeline: Strip EXIF metadata → Resize to 1920×1440 → Convert to WebP (85% quality) → Bundle into a single ZIP archive.
• Client Hardware: MacBook Air M2, 16GB RAM, Google Chrome 128, 100 Mbps broadband connection.

Benchmark Results§

NexaBatch achieved a 6× speedup over the cloud converter, primarily by completely bypassing the network bottleneck. While the local Python script achieved marginal CPU performance advantages due to native SIMD optimizations, NexaBatch delivered comparable speed without requiring a terminal, virtual environments, or external library installations.

Frequently Asked Questions (FAQ)§

What is NexaBatch and how does it work?§

NexaBatch is an AI-orchestrated batch processing tool built directly into NexaTools. It allows users to chain multiple file operations—such as image conversion, PDF merging, metadata removal, and file encryption—using natural language prompts. The system uses Google's Gemini 3.6 Flash model to convert your prompt into a structured execution plan, and then executes that plan entirely inside your web browser using WebAssembly, WebCodecs, and HTML5 APIs.

Are my uploaded files sent to an AI server?§

No. Your file contents are never uploaded to any server. When you submit a request, NexaBatch transmits only basic file metadata (file names, byte sizes, and MIME types) to the Gemini AI planner so it can understand what types of files you are processing. The actual data, pixels, text, and binary bytes remain strictly inside your browser's local memory sandbox.

Do I need to install any software or browser extensions?§

No. NexaBatch runs completely within any modern web browser that supports WebAssembly and HTML5 Canvas, including Google Chrome, Mozilla Firefox, Microsoft Edge, and Apple Safari. There are no command-line tools, browser extensions, or local runtimes to install.

What file formats and batch operations are supported?§

NexaBatch supports over 80 tool operations across various file categories. This includes images (JPEG, PNG, WebP, AVIF, SVG, BMP), documents (PDF, Markdown, HTML), structured data (JSON, CSV, XML, YAML), audio/video containers (MP4, MP3, WAV, WebM), and cryptographic operations (AES-256-GCM encryption, SHA-256 and MD5 hashing).

Is NexaBatch completely free to use?§

Yes. Because NexaBatch executes computations directly on your computer's local hardware rather than consuming expensive cloud server CPU clusters, NexaTools provides NexaBatch completely free without daily file limits, subscriptions, or paywalls.

What are the browser memory limits for batch processing?§

Modern desktop browsers typically allocate between 2GB and 4GB of memory per browser tab. Because NexaBatch streams files through memory pipelines and aggressively frees intermediate buffers using URL.revokeObjectURL(), you can comfortably process batches consisting of hundreds of images, dozens of PDFs, or multi-megabyte datasets without exhausting browser resources.

Conclusion & Getting Started§

The era of uploading sensitive personal photos, financial documents, and proprietary source code to centralized cloud conversion farms is coming to an end. Modern web browsers are no longer simple document viewers; they are robust, sandboxed operating environments capable of executing near-native compiled code.

With NexaBatch, NexaTools combines the best of both worlds: the cognitive flexibility of conversational AI with the privacy and performance of local-first execution.

Ready to automate your file workflows? Visit NexaBatch, drag in your first batch of files, and experience private, browser-native AI batch processing today. You can also explore our individual standalone utilities, including the NexaTools Image Converter, the PDF Merger, and the Client-Side File Transfer Tool.