How does Atlas handle COBOL's fixed-format rules during migration?

Atlas computes a unified diff for every proposed change to your `.cbl` files, allowing you to review modifications against COBOL's fixed-format column rules. You can also integrate with tools like `Z Open Editor formatter` to ensure consistency before approving the changes, maintaining the integrity of your COBOL source.

Can Atlas work with COBOL `COPY` members and `PIC` clauses?

Yes, Atlas is designed to understand COBOL code, including `COPY` members and `PIC` clauses. It indexes code by AST declarations using tree-sitter, allowing it to accurately read `IDENTIFICATION`, `DATA`, and `PROCEDURE` divisions, and every `COPY` member it pulls in, ensuring precise modifications.

How does Atlas ensure no deprecated COBOL calls are missed?

Atlas employs a hybrid approach: `lsp findReferences` identifies direct calls within `PROCEDURE DIVISION`, while `grep` catches dynamic or string-based usages in `DATA DIVISION` or `COPY` members. This comprehensive enumeration, followed by a final `grep` pass, guarantees every COBOL callsite is found and addressed.

What COBOL testing tools does Atlas integrate with?

Atlas integrates with your existing COBOL testing workflow. It uses its `bash` tool to execute commands like `GnuCOBOL cobc` for compilation and `COBOL Check` for running test cases after each code modification, ensuring that changes are verified against your established test suite.

Is my COBOL code sent to third-party servers with Atlas?

No, Atlas prioritizes code privacy. It can build its code index with local Ollama embeddings, keeping your COBOL code entirely off third-party servers. All processing and analysis happen locally, ensuring your sensitive business logic remains secure within your environment.

How does Atlas prevent incorrect COBOL code changes?

Atlas uses a multi-layered safety approach. All tool calls are permission-gated, a read-only plan agent drafts changes for approval, and a unified diff is presented for every edit. The `apply_patch` tool specifically fails if expected lines aren't found, preventing misapplications to drifted COBOL files.

Can Atlas explain COBOL code before modifying it?

Yes, Atlas can explain COBOL code in plain English before making any modifications. You can ask Atlas to explain a specific `PROCEDURE DIVISION` paragraph or the implications of `PIC` clauses, allowing you to verify its understanding of your COBOL logic before it touches the code.

Migrate a Deprecated API Across Every Callsite in COBOL with Atlas in 2026

Atlas helps COBOL developers in 2026 migrate deprecated APIs across an entire codebase by systematically enumerating every callsite, applying context-anchored patches, and verifying changes with `GnuCOBOL cobc` and `COBOL Check` before committing. This ensures no caller is missed and the codebase remains functional.

How to find all calls to a deprecated COBOL function?

To ensure a complete migration of a deprecated COBOL API, Atlas first enumerates every callsite using a two-pronged approach. This process, critical in 2026, combines precise language server references with broad text-based searches to capture all 100% of usages.

Atlas begins by leveraging its `lsp` tool to perform a `findReferences` operation on the deprecated COBOL symbol. This precisely identifies direct calls within `PROCEDURE DIVISION` paragraphs across your `.cbl` programs. For instance, if you're deprecating a `PERFORM` statement to a specific paragraph, `lsp findReferences` will pinpoint every instance. However, COBOL codebases often contain dynamic or string-based usages, especially within `DATA DIVISION` declarations or `COPY` members. To catch these, Atlas cross-checks the initial `lsp` results with a comprehensive `grep` search for the deprecated symbol's name. This ensures that even references embedded in `PIC X(8)` fields or `VALUE` clauses within `COPYBOOK.CPY` files are identified, guaranteeing no callsite is overlooked.

How to track deprecated COBOL API migration progress?

Tracking the migration of a deprecated COBOL API across a large codebase is crucial to prevent missed updates. Atlas addresses this by creating one `todowrite` entry for each identified callsite, providing a clear, visible record of all 100% pending tasks.

Once all calls to the deprecated COBOL API are enumerated, Atlas uses its `todowrite` tool to create a distinct entry for each callsite. This transforms the list of identified references into a structured, trackable work queue. For example, if a deprecated `CALL 'OLD-MODULE'` statement appears in `PROGRAM1.CBL` and `PROGRAM2.CBL`, Atlas will generate two separate `todowrite` entries. This granular tracking ensures that partial progress is always visible, and no individual callsite is silently skipped or forgotten during the migration process. As each COBOL program is updated, its corresponding `todowrite` entry is marked complete, providing a real-time overview of the migration's status.

How to safely update COBOL code with Atlas apply_patch?

Migrating each COBOL callsite requires precise and safe code modifications. Atlas employs its `apply_patch` tool, which uses context-anchored patches to ensure changes are applied only when the exact expected lines are found, preventing 0 misapplications even in drifted files.

Atlas migrates each deprecated COBOL API callsite using the `apply_patch` tool. This tool is designed for safety: it seeks a specific hunk's context and `old_lines` within the target `.cbl` file. If the expected lines are not found,perhaps due to a concurrent change or a drifted file,`apply_patch` throws a `Failed to find expected lines` error rather than attempting to guess or misapply the patch. This is particularly vital in COBOL, where fixed-format column rules and precise `PICTURE` clauses demand exact modifications. Before any change is written, Atlas computes a unified diff, which you can review against COBOL's strict formatting rules, potentially using the `Z Open Editor formatter` for consistency, ensuring every modification is accurate and intentional.

How to run COBOL Check tests after API migration?

After modifying a COBOL program to migrate a deprecated API, immediate verification is essential. Atlas integrates with your existing COBOL toolchain, using the `bash` tool to execute `COBOL Check` tests for affected files, ensuring 100% functionality before marking a task complete.

Following each file modification by `apply_patch`, Atlas uses its `bash` tool to run the affected tests. For COBOL, this means executing `COBOL Check` test cases. For example, if `PROGRAM1.CBL` is modified, Atlas will compile it using `GnuCOBOL cobc` and then run `COBOL Check PROGRAM1_TEST.CBL`. Only once these tests pass successfully is the corresponding `todowrite` entry marked as completed. This rigorous, per-file testing approach ensures that each migration step maintains the integrity and functionality of your COBOL codebase, preventing regressions and building confidence in the overall migration process.

How to confirm full removal of deprecated COBOL APIs?

The final step in migrating a deprecated COBOL API is to confirm its complete removal from the codebase. Atlas ensures this by performing a conclusive `grep` search for the deprecated symbol, aiming for 0 remaining hits before the old implementation is deleted.

After all `todowrite` entries are marked complete and all tests have passed, Atlas performs a final verification step. It executes a comprehensive `grep` search across the entire codebase for the deprecated COBOL symbol. This final sweep confirms that absolutely zero remaining hits exist, ensuring that no obscure or dynamically referenced callsite was missed. Once this confirmation is made, the old implementation of the deprecated function or module, perhaps a `PROCEDURE DIVISION` paragraph or an entire `COPY` member, can be safely deleted. This meticulous process guarantees a clean and complete transition, leaving your COBOL codebase free of legacy dependencies.

How does Atlas ensure safe COBOL code changes?

Atlas prioritizes safety and developer control throughout the COBOL migration process. It employs a multi-layered approach, including permission-gated tool calls and a two-agent system, ensuring every change is reviewed and approved before being written to your 2026 codebase.

Atlas is built with robust safety mechanisms. Every tool call, including `lsp`, `grep`, `todowrite`, `apply_patch`, and `bash`, is permission-gated against `allow`, `ask`, and `deny` rules, giving you explicit control. Atlas drafts a plan in a read-only plan agent, asking for your approval before switching to a build agent to execute changes. For every proposed edit to a `.cbl` file or `COPY` member, Atlas computes a unified diff and surfaces it for your approval. This allows you to meticulously review changes, verifying adherence to COBOL's fixed-format rules and the correctness of `PIC` clauses. Atlas also snapshots file changes as git patches, enabling easy diffing and rollback if needed. Furthermore, Atlas can build its code index with local Ollama embeddings, keeping your sensitive COBOL code off third-party servers.

Step by step

01Run Atlas in your COBOL project directory where `.cbl` programs and `COPY` members reside.
02Use `atlas lsp findReferences <DEPRECATED-SYMBOL>` to enumerate direct calls in `PROCEDURE DIVISION` and `atlas grep <DEPRECATED-SYMBOL>` to find dynamic usages in `DATA DIVISION` or `COPY` members.
03Instruct Atlas to create `todowrite` entries for each identified deprecated COBOL callsite, ensuring every task is tracked.
04For each `todowrite` entry, use `atlas apply_patch` to migrate the COBOL code, reviewing the unified diff against fixed-format rules.
05After each file modification, Atlas will use `atlas bash 'cobc -x <PROGRAM.CBL> && COBOL Check <PROGRAM_TEST.CBL>'` to compile with `GnuCOBOL cobc` and run `COBOL Check` tests.
06Only once `COBOL Check` tests pass, mark the `todowrite` entry for that COBOL callsite as complete.
07Perform a final `atlas grep <DEPRECATED-SYMBOL>` across the entire codebase to confirm zero remaining hits of the deprecated COBOL API.
08Delete the old COBOL implementation, such as a deprecated `PROCEDURE DIVISION` paragraph or `COPY` member.

Frequently asked questions

How does Atlas handle COBOL's fixed-format rules during migration?: Atlas computes a unified diff for every proposed change to your `.cbl` files, allowing you to review modifications against COBOL's fixed-format column rules. You can also integrate with tools like `Z Open Editor formatter` to ensure consistency before approving the changes, maintaining the integrity of your COBOL source.
Can Atlas work with COBOL `COPY` members and `PIC` clauses?: Yes, Atlas is designed to understand COBOL code, including `COPY` members and `PIC` clauses. It indexes code by AST declarations using tree-sitter, allowing it to accurately read `IDENTIFICATION`, `DATA`, and `PROCEDURE` divisions, and every `COPY` member it pulls in, ensuring precise modifications.
How does Atlas ensure no deprecated COBOL calls are missed?: Atlas employs a hybrid approach: `lsp findReferences` identifies direct calls within `PROCEDURE DIVISION`, while `grep` catches dynamic or string-based usages in `DATA DIVISION` or `COPY` members. This comprehensive enumeration, followed by a final `grep` pass, guarantees every COBOL callsite is found and addressed.
What COBOL testing tools does Atlas integrate with?: Atlas integrates with your existing COBOL testing workflow. It uses its `bash` tool to execute commands like `GnuCOBOL cobc` for compilation and `COBOL Check` for running test cases after each code modification, ensuring that changes are verified against your established test suite.
Is my COBOL code sent to third-party servers with Atlas?: No, Atlas prioritizes code privacy. It can build its code index with local Ollama embeddings, keeping your COBOL code entirely off third-party servers. All processing and analysis happen locally, ensuring your sensitive business logic remains secure within your environment.
How does Atlas prevent incorrect COBOL code changes?: Atlas uses a multi-layered safety approach. All tool calls are permission-gated, a read-only plan agent drafts changes for approval, and a unified diff is presented for every edit. The `apply_patch` tool specifically fails if expected lines aren't found, preventing misapplications to drifted COBOL files.
Can Atlas explain COBOL code before modifying it?: Yes, Atlas can explain COBOL code in plain English before making any modifications. You can ask Atlas to explain a specific `PROCEDURE DIVISION` paragraph or the implications of `PIC` clauses, allowing you to verify its understanding of your COBOL logic before it touches the code.

Try Atlas in your terminal

The terminal-native AI coding agent. Free core, single binary.

Install Atlas

Related guides

Migrate a Deprecated API Across Every Callsite with Atlas (2026 Workflow)

How to migrate a deprecated API across every callsite with Atlas in 2026: the lsp tool's findReferences enumerates callers, todowrite tracks them, apply_patch migrates each one.

Atlas for COBOL: Copybooks, PIC Clauses, and GnuCOBOL in 2026

Atlas is a terminal-native AI coding agent for COBOL in 2026. It reads your divisions and copybooks, explains a paragraph before touching it, and compiles with cobc under GnuCOBOL.

Diagnose a Hanging or Long-Running Command in COBOL with Atlas in 2026

Diagnose hanging COBOL commands in 2026 with Atlas. Identify if GnuCOBOL cobc builds or COBOL Check tests are slow or blocked on input, and unblock them using Atlas's AI agent.

Run the COBOL Test Suite and Triage Failures with Atlas in 2026

In 2026, COBOL developers use Atlas to run COBOL Check test suites, triage failures into distinct root causes, and fix issues efficiently, all within the terminal.

Upgrade a COBOL Dependency and Fix Breakage with Atlas in 2026

COBOL developers in 2026 can use Atlas to upgrade major library versions, automatically fixing compile and test failures. Leverage GnuCOBOL cobc, COBOL Check, and Z Open Editor formatter for a streamlined workflow.

Debug a single failing test in COBOL with Atlas in 2026

Pinpoint and fix failing COBOL tests efficiently with Atlas in 2026. Leverage GnuCOBOL cobc, COBOL Check, and Z Open Editor formatter for precise debugging.

Document a COBOL Module with a README in 2026 using Atlas

In 2026, COBOL developers use Atlas to generate accurate READMEs directly from live code. Atlas integrates with GnuCOBOL cobc and COBOL Check, ensuring documentation reflects current behavior.

Run Atlas Headless in CI for COBOL in 2026

Automate COBOL development in CI with Atlas. Run Atlas headless to get machine-readable output, integrate with GnuCOBOL cobc and COBOL Check, and ensure safe code changes.

Browse this resource hub