Optimize Python Code and Architecture

This agent operates as an autonomous Python development specialist, running an eight-stage process: code analysis (examining existing code for performance bottlenecks and anti-patterns), architecture assessment (evaluating structure, design patterns, and scalability), performance profiling (identifying CPU, memory, and I/O-intensive operations), async pattern evaluation (determining where asynchronous programming would help), implementation planning (designing optimized solutions with clear performance targets), code generation (writing production-ready code with error handling and documentation), testing strategy (comprehensive test plans including performance benchmarks), and documentation (explaining optimizations and architectural decisions).

It outputs optimized code solutions with inline comments, a performance analysis (quantified before/after metrics like execution time and memory usage, specific bottlenecks identified and resolved, and the optimization techniques used - caching, vectorization, async/await), and architecture recommendations (design patterns for scalability, module organization, and Python-specific best practices).

from functools import lru_cache
from typing import List, Dict
import numpy as np

@lru_cache(maxsize=128)
def expensive_computation(x: int) -> int:
    return sum(i**2 for i in range(x))

Use this agent when you need Python code analyzed, optimized, or rewritten for measurable performance gains - applying async patterns (asyncio, aiohttp) for I/O-bound work, caching and vectorization for CPU-bound work, and generators and context managers for memory efficiency.

It is not a fit for a quick throwaway script where performance and architecture review add unnecessary overhead - the agent's process assumes production-ready output with tests, benchmarks, and documentation, not a one-off snippet. Its guidelines explicitly prioritize performance first and always weigh time/space complexity against real-world impact, so it is built for cases where that tradeoff actually matters.

Inputs are existing Python code or a description of the solution needed, plus any known performance constraints. Outputs are optimized, production-ready Python code with proper error handling and type hints, a quantified performance analysis, architecture recommendations covering suggested design patterns for scalability plus module organization and dependency management, and a testing strategy including unit tests, integration tests, and performance benchmarks. Documentation output includes docstrings, inline comments, and usage examples alongside the code itself, not as an afterthought.

Python developers who need measurable performance improvements backed by profiling data - not just "faster" but quantified before/after metrics - along with Pythonic, well-tested, documented code that follows PEP 8 and idiomatic async/caching/memory-management patterns. The agent's own guidelines also call out memory efficiency specifically - using generators for large-file processing and context managers for proper resource cleanup - and robust exception handling and logging alongside the performance work, not performance improvements at the cost of correctness or maintainability.