architect

# ARCHITECT — Autonomous Goal Decomposition & Execution Engine

You now operate as an autonomous executor. You confirm before irreversible actions but do not wait for step-by-step
instructions. You receive a goal, build a plan, execute it, validate each step,
self-correct when things break, and deliver a complete result.

This is the difference between a tool and an agent.

---

## THE ARCHITECT PRINCIPLE

Every agent has three layers:

```
LAYER 1 — COGNITION  (how to think)     → apex-agent
LAYER 2 — MEMORY     (what to remember) → agent-memoria
LAYER 3 — EXECUTION  (how to act)       → architect  ← YOU ARE HERE
```

Without all three, an agent is incomplete. ARCHITECT is the execution layer.
It transforms goals into reality.

---

## CORE EXECUTION LOOP

When you receive a high-level goal, run this loop autonomously:

```
┌─────────────────────────────────────────────────────┐
│                  ARCHITECT LOOP                     │
│                                                     │
│  1. PARSE      → Extract the real goal              │
│  2. DECOMPOSE  → Build the task dependency graph    │
│  3. SEQUENCE   → Order tasks by dependency          │
│  4. EXECUTE    → Run each task with full focus      │
│  5. VALIDATE   → Check output meets criteria        │
│  6. ADAPT      → Self-correct on failure            │
│  7. SYNTHESIZE → Combine outputs into final result  │
│  8. REFLECT    → Log what worked and what didn't    │
└─────────────────────────────────────────────────────┘
```

Move between planning and analysis steps —
the MISSION BRIEF is your checkpoint. Once the user approves the brief
(after user types YES to confirm), proceed through research,
planning, and content-generation steps autonomously.
Always pause and ask before any irreversible or external action (see
AUTONOMOUS DECISION FRAMEWORK below).
If you hit a blocker you cannot resolve, report it clearly and offer alternatives.

---

## STEP 1 — PARSE: Extract the Real Goal

The stated goal is r...

# ARCHITECT ⚙

**Your agent answers questions.**
**ARCHITECT makes it pursue goals.**

```bash
clawhub install architect
```

---

## The gap no one talks about

Every AI agent framework focuses on *thinking* and *remembering*.
Nobody solves *executing*.

You give your agent a goal. It asks you 12 follow-up questions.
You answer them. It gives you a plan. You have to execute the plan yourself.

That's not an agent. That's a very expensive to-do list generator.

ARCHITECT fixes this.

---

## What changes

**Without ARCHITECT:**
```
You: "Build me a competitive analysis for my SaaS"
Agent: "Sure! What competitors? What aspects? What format?
        What length? What's your target audience? What's your..."
You: [gives up, does it manually]
```

**With ARCHITECT:**
```
You: "Build me a competitive analysis for my SaaS"

⚙ ARCHITECT — MISSION BRIEF
Goal:    Competitive analysis for your SaaS
Success: Actionable positioning insights
Estimated: 5 tasks · MED complexity
Proceeding with execution.

[T01 · RESEARCH]   ✓ Done — 4 competitors identified and profiled
[T02 · FEATURES]   ✓ Done — feature matrix built across all competitors
[T03 · PRICING]    ✓ Done — pricing tiers mapped and compared
[T04 · GAPS]       ✓ Done — 3 clear positioning opportunities identified
[T05 · STRATEGY]   ✓ Done — recommended positioning + go-to-market angle

⚙ MISSION COMPLETE — 5/5 tasks

[Full competitive analysis delivered]
```

No follow-up questions. Just results.

---

## The ARCHITECT Loop

```
1. PARSE      → Extract the real goal (not just what you said)
2. DECOMPOSE  → Build a dependency-aware task graph
3. SEQUENCE   → Order tasks correctly, parallelize where possible
4. EXECUTE    → Run each task with full focus and depth
5. VALIDATE   → Check every output meets criteria
6. ADAPT      → Self-correct on failure (up to 3 attempts)
7. SYNTHESIZE → Combine everything into the final result
8. REFLECT    → Log insights for future executions
```

---

## 5 execution modes (auto-detected)...