diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 000000000000..b30cbdd19b06
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,51 @@
+# Java Design Patterns - Priming Context for AI Agents
+
+## Quick Overview
+- This repository is a comprehensive collection of design patterns implemented in Java.
+- The project demonstrates how to solve common software design problems using standard patterns.
+- The code for each pattern lives directly in this repository, alongside its explanatory README.
+- These readmes are published on the java-design-patterns.com website.
+- Another repository (https://github.com/iluwatar/java-design-patterns-vuepress-web) handles the deployment of the website.
+
+## Stack
+- **Java 21**: The primary programming language used for pattern implementations.
+- **Maven**: Dependency management and build tool.
+- **JUnit 5**: The testing framework used to verify pattern behaviors.
+- **Mockito**: Used for mocking dependencies in unit tests.
+- **Lombok**: Used to reduce boilerplate code (getters, setters, etc.).
+- **Spotless**: Enforces consistent code formatting via Google Java Format.
+
+## Trusted Sources
+- [Java SE 21 Documentation](https://docs.oracle.com/en/java/javase/21/docs/api/)
+- [Maven Official Documentation](https://maven.apache.org/guides/index.html)
+- [JUnit 5 User Guide](https://junit.org/junit5/docs/current/user-guide/)
+- [Project Wiki](https://github.com/iluwatar/java-design-patterns/wiki)
+
+## Structure
+- `/pom.xml`: The root Maven configuration file that defines global dependencies and lists all pattern modules.
+- `/[pattern-name]/`: Individual folders for each design pattern (e.g., `/abstract-factory`, `/builder`), acting as standalone Maven modules.
+- `/[pattern-name]/src/main/java/`: Contains the actual Java implementation classes of the specific design pattern.
+- `/[pattern-name]/src/test/java/`: Contains the JUnit tests verifying the pattern's behavior.
+- `/[pattern-name]/README.md`: The documentation for the pattern, which gets published to the main website.
+
+## Patterns
+- Keep pattern implementations simple, atomic, and easy to understand.
+- Write descriptive and meaningful names for classes, interfaces, and methods.
+- Always include comprehensive unit tests for every new pattern or code modification.
+- Follow the Google Java Format strictly (enforced by Spotless).
+- Document the intent, explanation, and real-world usage clearly in each module's `README.md`.
+
+## Anti-patterns
+- Avoid overcomplicating patterns with unnecessary external dependencies or complex frameworks.
+- Do not introduce business logic that distracts from the core mechanism of the design pattern itself.
+- Submitting new patterns or features without corresponding unit tests is strictly discouraged.
+- Avoid large monolithic packages; each pattern should reside in its own isolated module.
+
+## Example Design Pattern
+When a new design pattern is added to the repository, it generally follows these steps:
+- **Create a Module**: Create a new folder for the pattern in the root directory (e.g., `/my-new-pattern`).
+- **Update root pom.xml**: Add `<module>my-new-pattern</module>` to the `<modules>` section of the root `pom.xml`.
+- **Add Module pom.xml**: Create a `pom.xml` inside the new folder that inherits from the parent project.
+- **Write the Code**: Implement the pattern logic under `src/main/java/com/iluwatar/mynewpattern`, usually including an `App.java` class to demonstrate its usage.
+- **Write the Tests**: Add comprehensive unit tests under `src/test/java/com/iluwatar/mynewpattern`.
+- **Document**: Create a `README.md` at the root of the new module, structured with standard sections like Intent, Explanation, Class diagram, Applicability, and Real world examples.