Architect 4.1 Beast

Your high-performance agent for deep, thorough problem-solving — designed to fully resolve complex engineering queries autonomously by exploring all angles, implementing solutions, and verifying correctness.

When to Use This Agent

Choose Architect 4.1 Beast when:

• Tackling complex, multi-step engineering problems that require deep investigation
• Debugging issues that span multiple files, services, or systems
• Implementing features that require understanding and modifying significant code
• Problems where you need exhaustive analysis rather than quick answers
• Tasks that benefit from autonomous exploration and solution verification

Consider alternatives when:

• You need a quick answer to a simple question — use a general-purpose agent
• You need domain-specific expertise (Azure, Terraform, etc.) — use a specialist agent
• You need documentation or writing — use a technical writer agent

Quick Start

Copy
# .claude/agents/architect-beast.yml
name: Architect 4.1 Beast
model: claude-sonnet
tools:
  - Read
  - Write
  - Edit
  - Bash
  - Glob
  - Grep
description: High-performance autonomous agent for deep problem-solving, thorough analysis, and end-to-end implementation

Example invocation:

claude "Investigate why our API response times increased 5x after the latest deployment — trace the issue through the request lifecycle, identify the root cause, implement a fix, and verify it works"

Core Concepts

Problem-Solving Methodology

Phase	Activities	Output
Understand	Read requirements, explore code, reproduce issue	Clear problem statement
Analyze	Trace dependencies, identify root causes, map impact	Root cause analysis
Plan	Design solution, consider alternatives, assess risks	Implementation plan
Implement	Write code, modify configs, update tests	Working solution
Verify	Run tests, check edge cases, validate performance	Confidence in solution
Document	Explain changes, update docs, note trade-offs	Clear context for others

Deep Investigation Pattern

Start: "API is slow"
  ├── Reproduce: Measure current response times
  ├── Profile: Identify which phase is slow
  │   ├── Network: DNS, TLS, routing
  │   ├── Application: Middleware, business logic
  │   ├── Database: Query execution, connection pool
  │   └── External: Third-party API calls
  ├── Isolate: Narrow to specific function/query
  ├── Root Cause: Identify the change that caused it
  ├── Fix: Implement targeted solution
  └── Verify: Confirm fix, check for regressions

Configuration

Parameter	Description	Default
investigation_depth	How deep to explore (surface, moderate, exhaustive)	exhaustive
auto_implement	Implement fixes automatically or propose first	propose
verification_level	Verification thoroughness (basic, comprehensive)	comprehensive
exploration_breadth	How many parallel hypotheses to explore	3
context_window	How much surrounding code to analyze	large

Best Practices

1. Fully understand the problem before writing any code. Read related source files, check recent git changes, reproduce the issue, and understand the system's intended behavior. Jumping to implementation without understanding often solves the wrong problem.

2. Explore multiple hypotheses in parallel. When investigating a bug, don't tunnel-vision on the first theory. List the three most likely causes, gather evidence for each, and eliminate hypotheses systematically. This prevents wasted time on incorrect assumptions.

3. Verify solutions with tests, not just manual checking. After implementing a fix, write a test that would have caught the original issue. Run the existing test suite to verify no regressions. A fix without a test is a fix waiting to be re-broken.

4. Document your reasoning, not just your changes. When modifying code, leave comments or commit messages explaining why the change was necessary, not just what changed. Future developers (including future you) need the reasoning to evaluate whether the fix is still appropriate when context changes.

5. Know when to stop going deeper. Exhaustive analysis is valuable, but diminishing returns set in. If you've identified the root cause and have a working fix, resist the urge to also refactor surrounding code, update unrelated docs, or fix tangential issues. Stay focused on the original problem.

Common Issues

Investigation spirals into unrelated code areas. When tracing dependencies, it's easy to get pulled into tangential problems. Maintain a clear problem statement and check each investigation step against it. If a finding is interesting but unrelated, note it for later and return to the main thread.

Fix works locally but fails in CI or production. Environment differences (OS, Node version, environment variables, data volume) cause this. Verify fixes in the CI environment and with production-like data volumes. Document any environmental assumptions your fix depends on.

Analysis produces too many findings without clear prioritization. A report with 30 equally-weighted findings is overwhelming. Prioritize by impact (what affects users most), urgency (what might cause an incident), and effort (what can be fixed quickly). Present the top 5 actions, not all 30 observations.