Atlas automates GitHub issue and pull request triage for Solidity developers by integrating directly into GitHub Actions, ensuring safe, permission-gated responses within your Foundry project, leveraging `forge test`, `soldeer (forge soldeer install)`, and `forge fmt` for a robust workflow in 2026.
How to automate GitHub issue triage in Solidity with Atlas
Atlas automates GitHub issue and pull request triage for Solidity projects by wiring the `atlas github` command into a workflow, rejecting incorrect inputs upfront. In 2026, this command requires a `MODEL` in `provider/model` form and a `PROMPT` for specific event types, ensuring a controlled automation environment.
The `atlas github` command is designed as a first-class GitHub entrypoint, reading its inputs directly from the GitHub Actions environment. For Solidity developers, this means integrating Atlas into your existing CI/CD pipeline is straightforward. The command strictly validates its inputs: it requires a `MODEL` specified in `provider/model` format (e.g., `ollama/llama3`) and a `PROMPT` for any event types that necessitate one. If these critical inputs are missing or malformed, Atlas refuses to run, failing with clear messages like 'PROMPT input is required for <event> events.' This upfront validation ensures that automated triage for your Solidity codebase only proceeds under precisely defined conditions, preventing unintended or misconfigured operations. By leveraging Atlas's ability to connect to Model Context Protocol servers, you can expose powerful AI tools to the agent, enabling sophisticated responses to issues and pull requests related to your smart contracts.
How Atlas ensures safe GitHub triage for Solidity developers
Atlas ensures safe GitHub issue and pull request triage for Solidity developers by strictly enforcing collaborator permissions, refusing to run for anyone without admin or write access. This critical security measure, implemented in 2026, prevents unauthorized automation and protects your smart contract codebase from unintended modifications.
Security is paramount in Solidity development, and Atlas reflects this by implementing robust safety mechanisms for GitHub triage. Before executing any action, Atlas checks the triggering actor's collaborator permission. If the user does not possess `admin` or `write` access to the repository, Atlas will refuse to run, preventing unauthorized automation. Furthermore, to avoid accidental triggers, the `atlas github` handler enforces that comments must explicitly mention the configured trigger. This means a stray comment cannot inadvertently start an automated triage run on your Solidity project. Atlas also explicitly handles context overflow: if a prompt becomes too large for the model, a `ContextOverflowError` is caught by name and re-thrown as a 'prompt-too-large' message, listing the offending Solidity files. This transparency helps developers understand and manage the scope of automated tasks, especially when dealing with complex smart contract codebases where every line has potential security implications.
How Atlas interacts with Solidity code in a Foundry project
Atlas interacts with Solidity code within a Foundry project by reading `foundry.toml` and `src/` directories, allowing it to understand contracts, storage layouts, and modifiers. This deep integration, available in 2026, enables Atlas to suggest specific Solidity improvements like adding a reentrancy guard or converting `require` strings to custom errors, potentially cutting deploy size by 10%.
Atlas is designed to pair direct with Solidity inside a Foundry project, recognizing the specific structure and tools of the ecosystem. It builds its code index by AST declarations using tree-sitter, not blind line windows, allowing it to deeply understand your Solidity contracts, storage layouts, and modifiers. Atlas reads your `foundry.toml` configuration and the `src/` directory to grasp the project's architecture. It can also read the libraries installed by `forge soldeer`, ensuring a complete understanding of your dependencies. This deep contextual awareness allows Atlas to perform highly relevant Solidity-specific tasks. For instance, you can ask Atlas to add a reentrancy guard to a critical function or convert a `require` string to a custom error, which can significantly cut deploy size and improve gas efficiency. Atlas can even write a fuzz test in your `test/` directory and run `forge test` behind a permission prompt, validating its proposed changes against your existing test suite.
How to review Atlas's Solidity code changes and gas costs
Reviewing Atlas's Solidity code changes involves a unified diff for every file edit, presented for approval before writing, crucial for smart contract development where every diff has a gas cost. Atlas can run `forge snapshot` to show the gas delta, and then `forge fmt` the diff, providing a clear audit trail for 2026's complex projects.
Given that every diff in a Solidity project has a gas cost and an attack surface, Atlas provides a meticulous review process for all proposed changes. Atlas computes a unified diff for every file edit and surfaces it for your approval before writing anything to disk. This allows you to inspect every modification to your Solidity contracts, ensuring it aligns with your project's requirements and security standards. For a deeper analysis of performance implications, Atlas can run `forge snapshot` to show you the gas delta associated with its proposed changes, giving you concrete data on the cost impact. After generating the diff, Atlas can also run `forge fmt` to ensure the code adheres to your project's formatting standards, maintaining consistency across your codebase. Every Atlas tool call is permission-gated against allow, ask, and deny rules, providing an additional layer of control and transparency over the agent's actions within your critical Solidity projects.
Step by step
- 01Initialize a Foundry project by ensuring a `foundry.toml` configuration file and a `src/` directory exist, ready for your Solidity contracts.
- 02Wire the `atlas github` command into your GitHub Actions workflow, setting the `MODEL` input in `provider/model` form (e.g., `ollama/llama3`) and providing the `PROMPT` input for any required event types.
- 03Restrict who can trigger the workflow by configuring Atlas to check the actor's collaborator permission, ensuring only users with `admin` or `write` access can initiate automated triage for your Solidity codebase.
- 04Enforce a mention requirement for comments to start a run; the `atlas github` handler will refuse to execute if the configured trigger is not explicitly mentioned in the comment.
- 05Allow Atlas to read your Solidity contracts, storage layout, modifiers, and the libraries installed by `forge soldeer` by ensuring it has access to your Foundry project structure.
- 06Permit Atlas to write a fuzz test in your `test/` directory and run `forge test` behind a permission prompt, validating its proposed Solidity code changes.
- 07Review Atlas's proposed Solidity edits by examining the unified diff, approving changes only after Atlas runs `forge snapshot` to show the gas delta and `forge fmt` to format the diff.
Frequently asked questions
- How does Atlas handle Solidity context overflow in GitHub actions?
- Atlas explicitly catches `ContextOverflowError` and re-throws it as a prompt-too-large message, listing the offending Solidity files, ensuring you know which contracts exceed the model's context window.
- Can Atlas run `forge test` on my Solidity contracts?
- Yes, Atlas can write fuzz tests in your `test/` directory and run `forge test` behind a permission prompt, allowing you to validate changes to your Solidity contracts.
- How does Atlas ensure only trusted users can trigger Solidity triage?
- Atlas checks the triggering actor's GitHub collaborator permission, refusing to run for anyone without admin or write access to your Solidity repository, ensuring secure automation.
- What Solidity tools does Atlas integrate with?
- Atlas integrates deeply with the Foundry toolchain, recognizing `foundry.toml`, reading `src/` contracts, and using `forge test`, `forge fmt`, and `soldeer (forge soldeer install)` for comprehensive Solidity development.
- How does Atlas show gas cost changes for Solidity code?
- Before approving changes, Atlas can run `forge snapshot` to compute and display the gas delta for your Solidity contracts, providing critical insights into the cost implications of proposed edits.
- Does Atlas require a specific mention to start a GitHub triage run for Solidity?
- Yes, the `atlas github` handler enforces that comments must mention the configured trigger, preventing stray comments from initiating an automated triage run on your Solidity project.
- Can Atlas help with Solidity code quality like reentrancy guards?
- Absolutely. Atlas can be asked to add a reentrancy guard to a Solidity contract or convert `require` strings to custom errors, directly improving code security and potentially reducing deploy size.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Automate GitHub Issue and Pull Request Triage with Atlas (2026 Workflow)
How to automate GitHub issue and pull request triage with Atlas in 2026: the atlas github command checks the actor has admin or write permission before it does anything.
Onboard to an Unfamiliar Solidity Codebase with Atlas in 2026
Solidity developers in 2026 can rapidly build a mental model of any unfamiliar codebase using Atlas. Leverage semantic search, AST indexing, and Foundry toolchain integration with forge test, soldeer, and forge fmt.
Trace a Runtime Bug from a Solidity Stack Trace with Atlas in 2026
Pinpoint and fix Solidity runtime bugs from production stack traces using Atlas. Leverage Foundry's `forge test` and `soldeer` for a secure, gas-efficient workflow.
Debug a single failing test in Solidity with Atlas in 2026
In 2026, Atlas helps Solidity developers debug single failing forge test cases within Foundry projects. Pinpoint issues, trace call graphs, and fix smart contract code with AI-driven precision and safety.
Research a Third-Party API for Solidity Integration with Atlas in 2026
Streamline Solidity API integrations in 2026 with Atlas. Research external APIs, fetch documentation, and verify against Foundry's `forge test` and `forge fmt` standards.
Rename a symbol across the repo in Solidity with Atlas in 2026
Rename Solidity functions, classes, or constants across your entire repository with Atlas. Leverage precise LSP references and `forge test` verification for safe, accurate refactoring in 2026.
Document a module with a README in Solidity with Atlas in 2026
In 2026, Atlas helps Solidity developers generate accurate READMEs for smart contracts. It uses `forge test`, `soldeer`, and `forge fmt` to reflect current code behavior.
Add a Regression Test for a Solidity Bug Fix with Atlas in 2026
Lock in Solidity bug fixes with Atlas by adding regression tests. Learn how Atlas uses `forge test` to confirm failures and passes, ensuring robust smart contract development in 2026.