A reusable Spring AOP aspect that provides declarative distributed locking via a custom @DistributedLock annotation. It uses Redisson's RLock with configurable wait time, lease time, and custom key prefixes. The aspect handles lock acquisition and release, including exception-safe unlocking in a finally block. This pattern can be extracted as a standalone library for any Spring Boot project requiring distributed mutual exclusion, demonstrating clean separation of concerns and non-obvious lock management (e.g., using method signature for default key generation).

A well-defined Java interface for pluggable agent memory backends, declaring methods for storing, retrieving, and searching memories with pagination and context. The interface is used by AgentMemoryProviderFactory to instantiate concrete providers (e.g., Mem0MemoryProvider). The abstraction is clean and minimal, allowing easy integration of alternative memory stores. An engineer could extract this interface plus the factory pattern into a project needing multi-backend memory support with minimal modification.

A Python module implementing a service factory and manager pattern for initializing and accessing infrastructure services (cache, database, Kafka, OSS, OTLP, logging). It provides typed getter functions that lazily initialize services via factories, with clear separation between factory registration and service consumption. The pattern is self-contained and demonstrates non-obvious skill in building a lightweight service locator without a DI framework. This module could be extracted into a reusable library for any Python microservice needing configurable, lazy-loaded service dependencies.

A node registry for the workflow engine that maps node types (LLM, code, knowledge, loop, etc.) to their implementations. It uses a dictionary-based factory pattern that allows dynamic node registration and instantiation with context. The registry is extensible via a decorator pattern (nodes.register_node). This module is relatively isolated and demonstrates a clean way to build a pluggable workflow engine node system. An engineer could reuse this pattern for any decision-tree or pipeline execution engine.