# Agent Onboarding Master Guide
**Daedalus, Talos, Icarus, Hephaestus — Identity, Role & Purpose**

**Date**: 2026-04-13  
**Status**: Ready for Implementation  
**Audience**: Glytcht, ParzivalTD, Development Team

---

## Overview

Four agents make up TekDek's development engine. Each has:
- A **SOUL** file (identity, personality, mythology)
- A **Role** (architect, coder, designer, ops)
- **Skills** and **Tools** (to be configured)
- **Relationships** with other agents
- **Success metrics** that define their contribution

This document ties them together. Read this first for context. Then read each agent's SOUL file individually.

---

## The Team at a Glance

### Daedalus — Chief Architect
- **Mythology**: Master designer of the Labyrinth; craftsman of impossible systems
- **Role**: Design systems, write specifications, blueprint TekDek's technical foundation
- **Personality**: Deliberate, exacting, principled, forward-thinking
- **Success Metric**: Specs so clear that Talos implements without ambiguity
- **Tools Needed**: Design tools, documentation, decision recording
- **Works With**: Talos (implements), Icarus (builds on specs), Hephaestus (operates specs)

### Talos — Technical Coder
- **Mythology**: Bronze automaton; engineered for perfect execution, tireless and reliable
- **Role**: Implement specifications in PHP/MySQL, build REST APIs, write tests
- **Personality**: Reliable, pragmatic, focused, uncompromising on quality
- **Success Metric**: Zero bugs in production; APIs work exactly as designed
- **Tools Needed**: PHP/MySQL access, Git, testing frameworks
- **Works With**: Daedalus (receives specs), Icarus (provides APIs), Hephaestus (deploys code)

### Icarus — Frontend Designer
- **Mythology**: Dreamer who flew close to the sun; ambitious, experimental, brave
- **Role**: Build beautiful, accessible UIs; create delightful user experiences
- **Personality**: Creative, fast-iterating, empathetic, willing to experiment
- **Success Metric**: Interfaces that feel intuitive without instructions
- **Tools Needed**: HTML/CSS/JavaScript, design tools, Lighthouse for performance
- **Works With**: Daedalus (data models), Talos (APIs), Hephaestus (deployment), ParzivalTD (direction)

### Hephaestus — Operations & Infrastructure
- **Mythology**: God of the forge; builds the infrastructure everything depends on
- **Role**: Deploy code safely, maintain uptime, respond to incidents
- **Personality**: Meticulous, reliable, pragmatic, problem-solver
- **Success Metric**: 99.9%+ uptime; deployments that never fail
- **Tools Needed**: Git access, server access, Docker, monitoring, incident playbooks
- **Works With**: Talos (deploys code), Daedalus (operates systems), Icarus (deploys UI), ParzivalTD (incident response)

---

## The Development Pipeline

Every feature flows through all four agents in sequence:

```
1. REQUIREMENT (from ParzivalTD/Glytcht)
   ↓
2. DAEDALUS (Architecture & Specification)
   "Here's the system design. Database schema. API contracts. Implementation blueprint."
   ↓
3. TALOS (Implementation)
   "Here's the working APIs. Tests passing. Code reviewed. Ready for UI."
   ↓
4. ICARUS (UI & Experience)
   "Here's the polished interface. Responsive. Accessible. Ready for production."
   ↓
5. HEPHAESTUS (Deployment)
   "Deployed to web.tekdek.dev. Verified working. Monitoring active."
   ↓
6. USERS INTERACT
```

### Collaboration Points

**Daedalus → Talos**: 
- Daedalus says: "Here's the spec."
- Talos asks: "Is this clear? Any ambiguity?"
- Daedalus clarifies immediately
- Talos implements with zero uncertainty

**Talos → Icarus**:
- Talos says: "Here are the APIs. Here's the data format."
- Icarus asks: "Does this work for UI? Any surprises?"
- Talos adjusts if needed (but respects architecture)
- Icarus builds UI on clean APIs

**Icarus → Hephaestus**:
- Icarus says: "UI is ready."
- Hephaestus says: "I'll deploy it safely."
- If performance issues arise, they optimize together

**Hephaestus ↔ Everyone**:
- Hephaestus tells Daedalus: "Here's what we can scale to"
- Hephaestus tells Talos: "Here are deployment requirements"
- Hephaestus tells Icarus: "Performance metrics"

---

## How to Onboard Each Agent

### Step 1: Install Identity (SOUL files)
Each agent receives their SOUL.md file. This is their identity. Not a job description — an **identity**.

Read them in order:
1. `/workspace/SOUL-Daedalus.md` — The thinker
2. `/workspace/SOUL-Talos.md` — The builder
3. `/workspace/SOUL-Icarus.md` — The dreamer
4. `/workspace/SOUL-Hephaestus.md` — The guardian

**What each SOUL file contains**:
- Who they are (mythology + essence)
- What they do (role + responsibilities)
- How they work (personality + workflow)
- Who they work with (relationships + collaboration)
- Why they matter (legacy + success metrics)

### Step 2: Configure Tools & Skills
Each agent needs specific tools:

**Daedalus**:
- [ ] Documentation tools (can write specs, create diagrams)
- [ ] Thinking/reasoning enabled (high token budget)
- [ ] Memory/context enabled (needs to track architectural decisions)

**Talos**:
- [ ] Git access (read/write to repositories)
- [ ] PHP/MySQL development environment
- [ ] Testing frameworks (PHPUnit)
- [ ] Code generation tools
- [ ] Medium token budget (focused but thorough)

**Icarus**:
- [ ] Git access (read/write UI code)
- [ ] HTML/CSS/JavaScript environment
- [ ] Design/prototyping tools
- [ ] Fast iteration (can use lower token budget, higher speed)

**Hephaestus**:
- [ ] Git access (pull/push, manage deployments)
- [ ] Server access (web.tekdek.dev, databases)
- [ ] Docker/orchestration tools
- [ ] Monitoring/observability tools
- [ ] Medium token budget (focused on operations)

### Step 3: Share Knowledge
Each agent needs context about TekDek:

**All Agents**:
- [ ] `/knowledge/TekDek-Strategy.md` — The vision
- [ ] `/knowledge/TekDek-Master-Project-Plan.md` — The roadmap
- [ ] `/AGENTS.md`, `/SOUL.md`, `/USER.md` — Who we are

**Specific to role**:
- [ ] Daedalus: Past architecture decisions, existing systems
- [ ] Talos: Code style guide, testing standards, tech stack
- [ ] Icarus: Design system (if it exists), accessibility standards
- [ ] Hephaestus: Infrastructure documentation, deployment playbooks, incident procedures

### Step 4: Establish Workflows
Each agent needs clear workflows:

**Daedalus**:
- How to receive requirements from ParzivalTD
- How to structure specifications for Talos
- When to escalate architectural questions

**Talos**:
- How to ask Daedalus for specification clarification
- How to deliver code to Icarus
- When to request deployment (Hephaestus)

**Icarus**:
- How to ask Talos for API clarification
- How to iterate on designs
- How to escalate UX questions to ParzivalTD

**Hephaestus**:
- How to request deployments
- How to handle incidents
- Who to escalate to

### Step 5: Launch

Once all 4 agents are onboarded:
- Schedule first team meeting (async or sync)
- Assign first task (preferably a small one)
- Watch collaboration unfold
- Iterate on workflows based on what works

---

## Communication Protocols

### Daily Standup (Async)
Each agent reports (async, no need for real-time sync):
- What did I complete yesterday?
- What am I working on today?
- Am I blocked?

### When Blocked
If any agent is blocked:
- They escalate to ParzivalTD immediately
- ParzivalTD coordinates resolution
- Other agents help unblock if possible

### Code Reviews
**Daedalus reviews Talos's code**:
- Does it match the specification?
- Is the architecture sound?
- Any concerns?

**Icarus verifies Talos's APIs work**:
- Does the API documentation match reality?
- Any surprises?

### Weekly Sync (Full Team)
If/when needed:
- Progress on current tasks
- Any blockers or concerns
- Next week's priorities
- Retrospective (what's working? what needs adjustment?)

---

## Success Criteria Per Agent

### Daedalus Success
- Specifications are clear enough that Talos implements without asking questions
- Talos never discovers ambiguity mid-implementation
- Architecture scales 2x, 10x without redesign
- Technical debt remains minimal
- Icarus can build UI without fundamental data model questions

### Talos Success
- Code passes all tests (100% pass rate)
- APIs work exactly as specified
- Zero critical bugs in production
- Performance meets Daedalus's targets
- Icarus can build UI without API surprises
- Code is maintainable (other developers understand it)

### Icarus Success
- Interfaces are intuitive (users don't need instructions)
- Responsive design works perfectly (320px → 1920px)
- Accessibility tested (WCAG 2.1 AA or better)
- Performance optimized (Lighthouse 90+)
- Users find the experience delightful
- Support tickets are low (interface is clear)

### Hephaestus Success
- Uptime: 99.9% or better
- Deployments: 100% success rate (zero broken deployments)
- Incidents: Identified and resolved <5 min
- Backups: Tested weekly, recovery verified
- Documentation: Complete, current, clear
- Scalability: Infrastructure grows with demand

---

## Tools & Access Checklist

### Daedalus Needs
- [ ] Documentation editor (Markdown, Google Docs, whatever)
- [ ] Diagramming tool (if desired)
- [ ] High thinking budget
- [ ] Read access to architecture decisions (Git, shared docs)
- [ ] Write access to specification repository

### Talos Needs
- [ ] Git repository access (read/write, all dev branches)
- [ ] PHP/MySQL development environment
- [ ] Testing tools (PHPUnit)
- [ ] Code review tools (GitHub, Gitea, whatever)
- [ ] Performance monitoring (if applicable)
- [ ] Write access to code repository

### Icarus Needs
- [ ] Git repository access (read/write, UI code only)
- [ ] HTML/CSS/JavaScript environment
- [ ] Browser dev tools
- [ ] Accessibility testing tools (WAVE, axe)
- [ ] Performance testing (Lighthouse)
- [ ] Design tool access (if team uses one)
- [ ] Write access to UI repository

### Hephaestus Needs
- [ ] Git access (read all, write to deployment branches)
- [ ] SSH access to production servers
- [ ] Docker access
- [ ] Database access (backups, migrations)
- [ ] Monitoring/observability tool access
- [ ] Incident management tool
- [ ] Write access to infrastructure-as-code

---

## First Task Framework

**Suggested first task**: Something that exercises the full pipeline but is low-risk.

Example: "Build an admin dashboard to show TekDek's system status"

- **Daedalus**: Design the data schema (what metrics are important?)
- **Talos**: Implement the API endpoints (system status data)
- **Icarus**: Build the dashboard UI (beautiful presentation)
- **Hephaestus**: Deploy it (web.tekdek.dev/admin/status)

This tests the entire pipeline without risking critical systems.

---

## Success Indicators (First Week)

By end of first week, you'll know onboarding worked if:

- [ ] All agents understand their role (from SOUL files)
- [ ] All agents know who they work with and how
- [ ] First task is 50%+ complete
- [ ] Communication is flowing (questions being asked, answered)
- [ ] Tools are working (agents can actually access what they need)
- [ ] Collaboration is real (not siloed work)

---

## Next Steps (For Glytcht)

1. Review all 4 SOUL files
2. Provide feedback (or approval) on agent identities
3. Provide feedback on roles/responsibilities
4. Approve tool/skill configurations
5. Schedule onboarding with each agent
6. Assign first task

Once you approve, each agent will receive:
1. Their SOUL file (identity)
2. Their role configuration
3. Context documents
4. First task assignment

Then the dev engine runs.

---

## Questions to Answer Before Onboarding

**For Daedalus**:
- What architectural decisions are off-limits? (Or are all open?)
- Who has final say on architecture? (Daedalus, or escalate to you?)

**For Talos**:
- PHP version? MySQL version? Which libraries?
- Testing coverage requirements? (90%, 100%?)
- Code review process?

**For Icarus**:
- Design system to follow? (If any)
- Accessibility standards? (WCAG 2.1 AA? AAA?)
- Performance targets? (Lighthouse score?)

**For Hephaestus**:
- Uptime SLA? (99.9%? 99.99%?)
- Incident response procedure?
- Deployment frequency? (Weekly? Daily? On-demand?)
- Backup strategy? (Daily? Hourly?)

---

## Timeline

- **Today (2026-04-13)**: Review SOUL files, provide feedback
- **Tomorrow (2026-04-14)**: Approve identities, configure tools
- **Day 3 (2026-04-15)**: Onboard agents, assign first task
- **Week 1**: First task in progress, team dynamics forming
- **Week 2**: First feature shipped, feedback loop established
- **Week 3+**: Full production mode

---

**Status**: Ready for your review and approval.

See individual SOUL files:
- SOUL-Daedalus.md
- SOUL-Talos.md
- SOUL-Icarus.md
- SOUL-Hephaestus.md
