Brain/AGENT-ONBOARDING-MASTER.md

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