# CTO Architect Prover MCP for AI Agents AI Agent Connect

> CTO Architect Prover validates your production architecture against real-world constraints. It stops your AI from recommending over-engineered stacks like Kubernetes for small teams. It forces your agent to justify every tech choice, redundancy path, and security threshold to ensure your system survives a real-world crash.

## Overview
- **Category:** architecture
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_YdavADROyg2WPJofrdpbLchuWnKVrqT5pSvFhlUk/ai-agent-connect
- **Tags:** cto, architecture, security, scalability, migration, observability, production

## Description

CTO Architect Prover stops your AI from suggesting a million-dollar infrastructure for a startup with three people. Most LLMs default to Resume-Driven Development, where they recommend complex tools like Kubernetes or Kafka just because they are popular, not because they make sense for your specific budget or team size. This Connector forces your AI client to think like a seasoned CTO who's been paged at 3 AM. It forces the AI to justify every tech choice against your actual constraints, name every redundancy mechanism for failover, and define specific security thresholds instead of just telling you to use HTTPS. You'll find it in the Vinkius catalog, where it acts as a gatekeeper for production-ready designs. It ensures your migrations don't lock tables and your observability actually includes real RTO and RPO targets. It's about moving past the happy path and into a design that actually survives a production crash.

## Tools

### validate_cto_architect
This tool performs a production-ready architecture validation. It forces your agent to justify every component against five critical axes like failure tolerance and migration safety.

## Prompt Examples

**Prompt:** 
```
We're a 3-person team building a simple SaaS. Can we use Kubernetes and Kafka for our backend?
```

**Response:** 
```
### Architecture Verdict: OVER_ENGINEERED

This design is a classic case of Resume-Driven Development. Here's why:

* **Stack Fitness**: Kubernetes and Kafka add massive operational overhead for a 3-person team. A Node.js or Python monolith with a managed database will ship faster and cost less.
* **Complexity**: You'll spend more time managing infrastructure than building features.

**Recommendation**: Start with a monolith. Move to microservices only when your team size and traffic actually require it.
```

**Prompt:** 
```
How should we migrate our production database to add a new subscription tier column?
```

**Response:** 
```
### Architecture Verdict: MIGRATION_BLOCKED

Your plan to take the system offline is rejected. We require a zero-downtime approach:

1. **Expand**: Add the column with a default value (no lock).
2. **Dual-Write**: Update the app to write to both the old and new logic.
3. **Backfill**: Batch-migrate existing rows.
4. **Switch**: Point reads to the new column.
5. **Contract**: Drop the old logic.

This ensures no downtime for your users.
```

**Prompt:** 
```
Give me a production-ready design for a high-traffic payment gateway.
```

**Response:** 
```
### Architecture Verdict: ARCHITECTURE_PROVEN

Your design meets all CTO-level requirements:

| Axis | Status | Details |
|---|---|---|
| **Stack** | Justified | Node.js monolith right-sized for your load. |
| **Failure** | Tolerated | Redis Sentinel, ALB health checks, and Stripe circuit breakers named. |
| **Security** | Hardened | JWT RS256 with 15m rotation, rate limits at 100/min, and AES-256 on PII. |
| **Migration** | Safe | Expand/contract pattern with tested rollbacks. |
| **Observability** | Proven | Health probes at /health/live, p99 < 200ms alerts, and RTO < 4h. |

**Status**: Production-ready.
```

## Capabilities

### Justify tech stack fitness
CTO Architect Prover ensures your AI client matches technology complexity to your actual team size and budget.

### Map out redundancy paths
CTO Architect Prover forces the agent to name every failover path and redundancy mechanism for every component.

### Define specific security thresholds
CTO Architect Prover requires named controls like rate limits and token rotation instead of generic advice.

### Plan zero-downtime migrations
CTO Architect Prover forces your agent to describe expand/contract patterns and parallel writes for all schema changes.

### Set RTO and RPO targets
CTO Architect Prover requires specific numbers for recovery times and data loss targets.

## Use Cases

### Auditing a startup's MVP stack
A founder asks the agent to design a SaaS. The agent wants to use Kafka and K8s. The Connector blocks this as over-engineered for a 3-person team.

### Planning a zero-downtime DB migration
An engineer needs to add a column to a live user table. The Connector forces the agent to define a dual-write and backfill strategy instead of a maintenance window.

### Hardening a public API's security
The agent proposes basic auth. The Connector forces it to define rate limits, JWT rotation schedules, and specific CORS whitelists.

### Verifying high-availability for a payment gateway
The agent designs a flow. The Connector forces it to name every circuit breaker, failover path, and specific RTO targets for every external service.

## Benefits

- Stop over-engineering by matching tech to your team size and budget using stack fitness checks.
- Identify single points of failure before you write a single line of code by mapping redundancy paths.
- Get specific security controls like rate limits and token rotation instead of vague advice.
- Ensure database migrations won't cause downtime or lock your production tables using expand/contract patterns.
- Move beyond checking logs to actual health probes and alerting thresholds with proven observability.
- Avoid Resume-Driven Development by forcing the AI to justify every technology choice against your specific constraints.

## How It Works

The bottom line is you get a production-ready architecture that actually fits your team's capabilities.

1. Input your proposed system design or architecture plan into your AI client.
2. The agent runs the validation check to test against five architectural axes.
3. You get a verdict identifying specific production-critical gaps or a proven architecture status.

## Frequently Asked Questions

**How does CTO Architect Prover stop my AI from suggesting over-complex tech?**
It forces your AI client to justify every technology choice against your specific team size, budget, and timeline. If the tech doesn't match your constraints, the Connector flags it as over-engineered.

**Can I use CTO Architect Prover to check my security plan?**
Yes. It requires the agent to move beyond generic advice like 'use HTTPS' and instead provide specific controls like rate limits, token rotation schedules, and encryption algorithms.

**Does CTO Architect Prover help with zero-downtime database migrations?**
It does. The Connector blocks any plans involving maintenance windows and forces the AI to describe specific expand/contract patterns and parallel write strategies.

**Will CTO Architect Prover help me find single points of failure?**
Yes. It requires your AI agent to name every redundancy mechanism and failover path for every component in your architecture, ensuring you don't have any single points of failure.

**What kind of observability requirements does CTO Architect Prover enforce?**
It ensures your agent defines specific health probes, metric dashboards with alert thresholds, and clear RTO and RPO targets instead of just saying 'we will monitor it'.

**Is CTO Architect Prover good for startup founders?**
It's perfect for founders who need to ensure their initial architecture is scalable but not unnecessarily expensive or complex for their current team size.

**What is 'Resume-Driven Development'?**
It is when engineers choose technologies because they look impressive on a resume, not because they solve the problem. Kubernetes for a 3-person seed team with 50 users is Resume-Driven Development. A monolith with PostgreSQL would ship in 8 weeks. Kubernetes adds 3 months of operational overhead for no user benefit.

**Why does it reject 'use HTTPS' as a security strategy?**
Because HTTPS is the bare minimum, not a strategy. A hardened security posture requires rate limiting with specific thresholds (100 req/min per IP), parameterized queries to prevent SQL injection, JWT with RS256 and rotation policy, CORS whitelisting, and data-at-rest encryption with a named algorithm (AES-256). Saying 'use HTTPS' is like saying 'lock the door' — it does not address the windows.

**Why is 'maintenance window' blocked?**
Because zero-downtime is the production standard. Maintenance windows are an admission that your migration strategy cannot handle live traffic. Use the expand/contract pattern: add the new column, dual-write, backfill, switch reads, drop the old column. Each step is reversible. Each step handles live traffic. If your migration requires downtime, your architecture is not production-ready.