Roads arrive in one coordinate system, parcel boundaries in another, and facility locations in a GeoPackage containing several layers. Before analysis can begin, each dataset needs to use the approved CRS and cover the same project area. Repeating those steps manually makes it easy to select the wrong layer, overwrite an output, or miss a failed transformation.

Codex can help turn that preparation into a repeatable batch workflow. QGIS’s Processing Executor (qgis_process) performs the reprojection and clipping, while Codex helps inspect inputs, prepare commands, and record results.

On Vagon Cloud Computer, QGIS, Codex, your datasets, and the automation tools share one Windows workspace. You can review the layers, run the batch, inspect outputs in QGIS, and prepare the delivery package without moving between computers.

This guide focuses on 2D vector layers. We will verify one reprojection-and-clip operation, extend it to an explicit layer list, and check that the outputs preserve the information the project needs.

Source: QGIS Documentation

Define the Output Package Before Processing Anything

Start with the delivery requirements rather than a folder-wide command. “Reproject and clip everything” leaves important decisions unresolved: which layers belong in the package, what CRS they need, and which boundary defines the project area.

For this walkthrough, prepare roads, parcels, and facility points using these rules:

Keep each geometry type separate. Preparing these datasets together does not require merging roads, parcels, and points into one layer.

Decide whether you need clipping or selection

QGIS’s Clip algorithm retains only the geometry inside the polygon boundary. A road crossing the boundary is cut at that boundary.

That differs from selecting every feature that intersects the AOI, which can retain the entire road. Confirm that clipped geometry is the intended deliverable before running the batch.

Preserve an existing stable source identifier where available. Do not rely on output feature IDs remaining unchanged. Also identify stored area or length fields: clipping changes geometry without automatically recalculating those attributes.

The result should be a defined package, not just several new files. Each output needs a clear name, a traceable source, and acceptance checks that Codex can apply consistently.

Prepare QGIS and Codex on Vagon Cloud Computer

Keep QGIS Desktop and the batch runner in the same environment. That lets Codex prepare commands against the actual datasets while you inspect the same inputs and outputs visually.

1. Select the applications

During Vagon computer creation, use application selection to choose QGIS, Codex, and Python.

Once the desktop is ready, open QGIS and record its version. Sign in to Codex and open the project directory. Application installation and permission to execute commands are separate, so confirm the agent’s access before starting the batch.

2. Check the QGIS command-line environment

Use the command environment supplied by your QGIS installation. Depending on the Windows package, this may involve an OSGeo4W shell or a launcher that configures the required paths.

Run:

If the command is unavailable in a normal terminal, locate the installation’s supported launcher rather than assuming QGIS is broken. Ask Codex to preserve that environment when invoking commands.

The Processing Executor runs QGIS algorithms without opening Desktop. A separate Python runner can call it without importing PyQGIS, so this route does not require installing a qgis package into an ordinary Python environment.

3. Transfer complete datasets

Use Vagon Files to transfer the inputs and AOI. Keep Shapefile components together and identify the intended sublayers inside GeoPackages.

Separate sources from generated files:

Open representative inputs in QGIS to confirm they are readable. Keep source datasets unchanged, and direct Codex to write only to the designated analysis folders. The next step is to inventory every layer before choosing transformation parameters.

Inventory Layers, Not Just Files

A directory listing is not enough to define a GIS batch. One GeoPackage can contain several vector layers, while a Shapefile depends on companion files. Codex needs an explicit inventory of the layers to process, not a rule that treats every filename as one input.

Source: QGIS Documentation

Ask for a read-only inspection:

Record the results in a manifest:

Include feature counts and extents in the inspection report as baseline observations. Treat the declared CRS as metadata to verify, not proof that the coordinates were labeled correctly. An unusual extent is a reason to investigate, not permission for Codex to guess another EPSG code.

Make the processing scope explicit

Confirm whether each manifest entry represents the complete layer or a filtered subset. A selection or filter active in QGIS Desktop may not be reproduced by a file-based command. If only selected features belong in the job, define that subset explicitly or save an approved working copy.

Likewise, do not assume that provider-generated feature IDs are permanent source identifiers. Preserve an appropriate existing key, or agree on an identification method before processing.

Finish with a reviewed manifest containing only the intended layers. Unknown CRS, unexpected dimensions, and ambiguous sublayers should remain marked for review rather than silently entering the batch.

Approve the CRS and Prepare the Clip Boundary

Before transforming any coordinates, confirm the source CRS for each layer and the target CRS required by the project. A familiar-looking map is not enough: QGIS can display layers together using on-the-fly transformations without changing their stored coordinates.

Separate CRS assignment from reprojection

Assigning a CRS changes how existing coordinates are interpreted. Reprojection calculates coordinates in another reference system.

If a layer has missing or incorrect CRS metadata, establish the correct source reference from reliable documentation before proceeding. Do not ask Codex to select an EPSG code merely because it makes the layer appear near the AOI.

Choose the target CRS for the project’s location and intended use. EPSG:3857 is not a universal choice for measurement simply because its coordinate units are meters.

Source: QGIS Documentation

Confirm the coordinate operation

Some source-to-target transformations offer multiple operations with different accuracy, coverage, or supporting grid requirements. QGIS’s datum transformation settings expose those choices.

Source: QGIS Documentation

Record the approved operation where one must be specified. Check that required transformation grids are available in the environment used by qgis_process. Do not assume a Desktop preference or downloaded grid is automatically available to a command running under another profile.

If the preferred operation cannot run, flag the problem rather than silently accepting a lower-accuracy fallback.

Prepare one reusable AOI

Check that the clip layer contains the intended polygon boundary, including any islands, holes, or multiple features. Confirm whether all polygons should participate or only an explicitly defined subset.

Validate its geometry before use. If repair is needed, preserve the original and review the repaired copy rather than automatically replacing it.

Reproject the approved AOI into the target CRS once and save it separately. Each input layer can then be transformed to that CRS and clipped against the same prepared boundary.

Keep this example limited to 2D data. Layers with elevation or measure coordinates require additional decisions about preserving or transforming those dimensions. Codex should flag them for review, not assume that a horizontal reprojection also performs a valid vertical transformation.

Verify One Reproject-and-Clip Run in QGIS

Start with one representative layer, such as roads. Testing the complete sequence in QGIS Desktop gives you a result to inspect before Codex repeats it across the manifest.

Open Reproject layer from the Processing Toolbox. Select the exact input layer, set the approved target CRS, and specify the coordinate operation where required. Save the result in intermediate, keeping the source unchanged.

Source: QGIS Training Manual

Then open Clip:

Confirm that neither operation is restricted to an unintended selection. Use permanent output paths rather than leaving results as temporary layers.

Inspect the saved result

Reopen the output GeoPackage in QGIS. Check its CRS, required fields, and several features near the AOI boundary. Roads crossing the boundary should be cut; sections entirely outside should not remain.

Compare the reprojected intermediate layer with the clipped result so transformation problems are distinguishable from clipping problems. Keep the original source identifier available for tracing features.

Give Codex the successful commands

Open Processing History, locate the successful operations, and use Copy as qgis_process Command or Copy as JSON. These records provide the actual parameters used, including dataset references that may be more complex than a filename.

Source: QGIS Documentation

The command structure will resemble:

qgis_process run native:reprojectlayer -- \
  INPUT="<source dataset and layer>" \
  TARGET_CRS="<approved CRS>" \
  OUTPUT="<intermediate GeoPackage>"

qgis_process run native:clip -- \
  INPUT="<reprojected layer>" \
  OVERLAY="<prepared AOI layer>" \
  OUTPUT="<clipped GeoPackage>

qgis_process run native:reprojectlayer -- \
  INPUT="<source dataset and layer>" \
  TARGET_CRS="<approved CRS>" \
  OUTPUT="<intermediate GeoPackage>"

qgis_process run native:clip -- \
  INPUT="<reprojected layer>" \
  OVERLAY="<prepared AOI layer>" \
  OUTPUT="<clipped GeoPackage>

This illustrates the structure, not paste-ready Windows syntax. Use the commands copied from your installation, retaining any required coordinate-operation or project-context arguments.

Ask Codex to turn those verified operations into a reusable two-stage function. It should check the first stage before starting the second and report both output locations.

One successful roads layer does not validate every parcel polygon or point dataset. It establishes the processing pattern; each remaining layer still needs its own input and output checks.

Turn the Verified Steps into a Manifest-Driven Batch

Once the single-layer result passes review, ask Codex to apply the same sequence to the approved manifest. Each row should identify one source layer and a unique output name, including the sublayer name when the dataset contains several layers.

Source: QGIS Documentation

Process the rows sequentially at first. That makes failures easier to isolate and avoids multiple processes writing to the same GeoPackage.

Run commands without assembling a shell string

For a directly executable qgis_process installation, the Python calling pattern can look like this:

import subprocess

command = [
    qgis_process_executable,
    "run",
    "native:clip",
    "--",
    f"INPUT={reprojected_layer}",
    f"OVERLAY={prepared_aoi}",
    f"OUTPUT={output_path}",
]

import subprocess

command = [
    qgis_process_executable,
    "run",
    "native:clip",
    "--",
    f"INPUT={reprojected_layer}",
    f"OVERLAY={prepared_aoi}",
    f"OUTPUT={output_path}",
]

The variables must come from validated configuration and manifest entries. Pass paths as individual arguments, without adding literal quotation marks around them. If your Windows installation requires a launcher to establish the QGIS environment, preserve that supported invocation rather than substituting an unconfigured executable.

Save both standard output and error messages for every stage. A zero return code is an execution check, not proof that the resulting layer meets the delivery requirements.

Give every layer an explicit outcome

Use four statuses:

An empty clip may be correct when the source does not intersect the AOI. It may also indicate a wrong layer, CRS, or boundary. Record it rather than silently deleting it.

Test the runner on a small subset before expanding. Keep partial outputs separate from accepted deliverables, and skip previous results only when their source identity, settings, and validation record match the current job.

Validate More Than the CRS Label

A layer can report the expected CRS and still be misplaced, incomplete, or unsuitable for delivery. Validate the saved outputs, not just the processing messages.

Start by reopening each GeoPackage. Confirm the intended layer is present and readable, then compare its recorded properties with the manifest.

Inspect the boundary and representative features

In QGIS, overlay the output with the prepared AOI and reprojected intermediate layer. Examine crossing roads, parcels intersected by the boundary, polygon holes, and points close to the edge.

Feature counts are useful diagnostics, not a universal pass/fail rule. Clipping can remove features outside the AOI and change geometry structure. Investigate unexpected differences, but do not require the output count to equal the source count.

Likewise, do not assume output feature IDs preserve source identities. Check the stable identifier selected earlier. If one source feature produces multiple output records under the chosen processing steps, retain that relationship explicitly.

Source: QGIS Documentation

Review geometry-dependent attributes

QGIS’s Clip documentation warns that stored attribute values are not automatically updated when geometries change. A parcel’s original area or a road’s original length may therefore describe the uncut feature.

Preserve those values if they are source attributes, but label them accordingly. If the deliverable requires clipped area or length, calculate new fields using an approved measurement method and stated units. Do not overwrite authoritative source values without agreement.

Ask Codex to generate a validation summary with counts, checks, warnings, and unresolved findings for each layer. Mark an output completed only after the required checks pass. Finally, inspect the delivery package in a fresh QGIS project so missing dependencies or temporary-layer references are not concealed by the working session.

Source: QGIS Documentation

Handle Failed Layers Without Hiding Data Changes

When a layer fails, identify whether the problem occurred during input loading, reprojection, clipping, or output validation. Keep the complete processing message so Codex can investigate the cause rather than repeatedly changing parameters until a file appears.

Do not use “skip invalid features” as a general repair strategy. It can produce a plausible output while omitting data. If geometry repair is approved, save a separate working copy and record affected features and structural changes.

Source: QGIS Documentation

For large layers, measure one representative run before increasing concurrency. CPU, RAM, storage throughput, spatial indexes, and geometry complexity can influence processing time. A larger GPU does not automatically accelerate these vector operations.

Keep the datasets and logs together on Vagon Cloud Computer while investigating failures. Resume only the affected manifest entries after correcting the cause, and retain their earlier failure records alongside the successful rerun.

Final Thoughts

A reliable batch workflow does more than repeat Reproject and Clip. It identifies the correct source layers, applies approved transformations, preserves required information, and records which outputs passed review.

Codex can help maintain that workflow as new datasets arrive. QGIS performs the spatial operations, while you approve the geographic assumptions and delivery checks.

Vagon Cloud Computer keeps QGIS, Codex, source data, and processing tools in one Windows workspace. Start with a verified layer, expand through the manifest, and retain the commands and validation records with the finished package.

FAQs

Do I need MCP to automate QGIS?

No. This workflow uses qgis_process and a Python runner. MCP is optional, not a requirement for executing QGIS Processing algorithms.

Can the batch run without opening QGIS Desktop?

Yes, once the command-line environment and parameters are configured. This guide uses Desktop to establish the first verified operation and inspect the resulting layers.

Does changing the project CRS reproject source files?

No. It changes the project’s display reference system. Use a reprojection operation and save a new output to transform stored coordinates.

Can one GeoPackage contain several input layers?

Yes. Identify the intended sublayer explicitly. A GeoPackage filename alone may not define which layer the batch should process.

Why do feature counts change after clipping?

Features outside the AOI are excluded, and intersecting geometries are cut. Additional processing choices can also affect geometry structure. Review unexpected changes using source identifiers rather than assuming equal counts.

Should invalid geometries be repaired automatically?

Not by default. Investigate first, obtain approval where required, and preserve the original. Record any changes introduced by the repair.

Can these commands process raster layers?

Not as written. Raster reprojection and clipping require different algorithms and decisions about resolution, resampling, grid alignment, and NoData. Prepare a separate workflow for those inputs.