diff --git a/agents/30-days-of-agents/day-11.mdx b/agents/30-days-of-agents/day-11.mdx
new file mode 100644
index 00000000..b73413e0
--- /dev/null
+++ b/agents/30-days-of-agents/day-11.mdx
@@ -0,0 +1,216 @@
+---
+title: "Day 11: Finance & Revenue Operations - Stripe Integration"
+sidebarTitle: "Day 11: Stripe Integration"
+description:
+ "Build a revenue operations agent that monitors payments, analyzes
+ subscription metrics, and provides financial insights through Stripe
+ integration."
+---
+
+
+ **Goal**: create a revenue operations agent with Stripe integration
+
+**Theme**: domain specialization week - financial intelligence
+
+**Time investment**: ~20 minutes
+
+
+
+Welcome to Day 11 and Week 3! You've mastered agent creation and workflows. Now
+you'll specialize in **domain-specific agents**—starting with finance and
+revenue operations through Stripe integration.
+
+This week is about building agents that don't just use tools, but understand the
+business context and best practices of specific domains.
+
+## What you'll accomplish today
+
+- Build a revenue operations agent that understands financial workflows
+- Connect Stripe for payment and subscription intelligence
+- Create automated revenue reporting and customer insights
+- Learn domain-specific patterns for financial agents
+
+
+ This builds on your Week 2 agent creation skills. You'll need a Stripe account
+ with appropriate permissions to complete today's integration.
+
+
+## Step 1: Understanding revenue agent patterns
+
+Financial agents need specialized knowledge beyond basic tool usage:
+
+### Domain expertise requirements
+
+Revenue agents must understand:
+
+- **Financial metrics**: MRR, churn, LTV, CAC, and their relationships
+- **Customer lifecycle**: Trial → paid → expansion → renewal patterns
+- **Risk indicators**: Failed payments, cancellations, downgrades
+- **Compliance needs**: Data privacy, financial reporting requirements
+
+
+ **Domain thinking** your agent should reason like a revenue operations
+ manager, not just fetch Stripe data.
+
+
+## Step 2: Create your revenue operations agent
+
+Work with Concierge to build a specialized financial agent:
+
+```text
+I want to create a revenue operations agent that monitors our Stripe payments and subscriptions.
+
+The agent should:
+- Track key revenue metrics (MRR, churn, new vs expansion revenue)
+- Identify at-risk customers based on payment patterns
+- Generate weekly revenue reports with insights
+- Alert on significant revenue events (large cancellations, payment failures)
+- Provide customer health scores based on payment history
+
+It should think like a revenue operations manager who understands SaaS metrics.
+```
+
+## Step 3: Connect and configure Stripe
+
+Add Stripe to your agent's connections:
+
+1. **Navigate to Connections** in your agent settings
+2. **Search for Stripe** and click "Add Connection"
+3. **Authenticate** with your Stripe account
+4. **Select appropriate permissions** (read access to payments, customers,
+ subscriptions)
+
+### Key Stripe capabilities for revenue agents
+
+Your agent can now:
+
+- **Analyze payment data**: Success rates, failure reasons, retry patterns
+- **Monitor subscriptions**: New, upgraded, downgraded, cancelled
+- **Track customer behavior**: Payment methods, billing cycles, usage patterns
+- **Generate insights**: Revenue trends, cohort analysis, forecasting
+
+## Step 4: Implement revenue intelligence workflows
+
+Test your agent with real revenue scenarios:
+
+```text
+Can you analyze our revenue performance this month and identify any concerning trends?
+```
+
+Your agent should:
+
+- Pull current month's transaction data from Stripe
+- Calculate key metrics (MRR, churn rate, growth rate)
+- Identify anomalies or concerning patterns
+- Provide actionable recommendations
+
+### Example revenue analysis
+
+```text
+What's our current MRR and how has it changed this quarter?
+Which customers are at risk of churning?
+```
+
+The agent analyzes:
+
+- **MRR trends**: Current MRR, growth rate, net new vs expansion
+- **Churn indicators**: Failed payments, downgrades, usage decline
+- **Customer health**: Payment reliability, engagement, upgrade potential
+- **Action items**: Customers needing attention, upsell opportunities
+
+## Step 5: Create automated revenue workflows
+
+Build repeatable revenue tasks:
+
+
+ **Coming soon** daily and weekly scheduled tasks. For now, you'll need to
+ interact with your agent through the UI to run these workflows.
+
+
+**Weekly revenue report**:
+
+```text
+Can you analyze last week's revenue performance including:
+- New vs lost MRR
+- Payment failure rate and recovery
+- Top customers by revenue
+- Churn risk assessment
+- Week-over-week comparison
+
+Format as an executive summary with key metrics and action items.
+```
+
+**Customer health monitoring**:
+
+```text
+Can you check for:
+- Failed payments needing attention
+- Customers with multiple failed attempts
+- Sudden usage drops indicating churn risk
+- Opportunities for upgrades based on usage
+
+Alert me only for critical issues needing immediate action.
+```
+
+
+ **Pro tip** set calendar reminders to run your revenue report weekly and
+ health checks daily until automated scheduling is available.
+
+
+## What you've accomplished
+
+In 20 minutes, you've built a domain-specific revenue operations agent:
+
+**Financial intelligence** agent that understands revenue metrics and SaaS
+business models
+
+**Stripe integration** connected payment and subscription data for real-time
+insights
+
+**Manual workflows** revenue reporting and customer health monitoring that you
+can run on-demand
+
+**Domain expertise** agent that thinks like a revenue operations manager, not
+just a data fetcher
+
+## The power of domain-specific agents
+
+Unlike generic agents, domain-specific agents:
+
+- **Understand context**: Know what metrics matter and why
+- **Identify patterns**: Recognize revenue risks before they become problems
+- **Provide insights**: Actionable recommendations, not just data dumps
+- **Automate expertise**: Scale revenue operations knowledge across your team
+
+
+ Development & infrastructure with GitHub and Vercel. Build agents that manage
+ code, deployments, and development workflows.
+
+
+## Pro tip for today
+
+Ask your revenue agent:
+
+```text
+Based on our payment patterns, what early warning signs should I watch for to prevent churn?
+```
+
+This helps your agent develop predictive capabilities specific to your business.
+
+---
+
+**Time to complete** ~20 minutes
+
+**Skills learned** domain-specific agent design, Stripe integration, revenue
+intelligence, automated financial workflows
+
+**Next** Day 12 - Development & infrastructure agents with GitHub and Vercel
+
+
+ **Remember** the best financial agents don't just report numbers—they
+ understand what those numbers mean for your business and what actions to take.
+
diff --git a/agents/30-days-of-agents/day-12.mdx b/agents/30-days-of-agents/day-12.mdx
new file mode 100644
index 00000000..ccd7d164
--- /dev/null
+++ b/agents/30-days-of-agents/day-12.mdx
@@ -0,0 +1,382 @@
+---
+title: "Day 12: Development & Infrastructure - GitHub & Vercel Integration"
+sidebarTitle: "Day 12: GitHub & Vercel"
+description:
+ "Master development workflows by building agents that manage code
+ repositories, automate reviews, handle deployments, and coordinate production
+ releases with GitHub and Vercel."
+---
+
+
+ **Goal**: build sophisticated development agents that automate code reviews, manage deployments, and coordinate release workflows
+
+**Theme**: domain specialization week - development & infrastructure
+
+**Time investment**: ~30 minutes
+
+
+
+Welcome to Day 12! Today you'll specialize in development and infrastructure by
+building agents that understand code, deployments, and development workflows.
+You'll integrate GitHub for repository management and Vercel for deployment
+automation, creating agents that act like senior DevOps engineers.
+
+This isn't just about connecting tools—it's about building agents that
+understand development best practices, can review code intelligently, and manage
+production deployments safely.
+
+## What you'll accomplish today
+
+- Build a development agent that combines GitHub and Vercel capabilities
+- Create intelligent code review workflows that go beyond syntax checking
+- Implement automated deployment pipelines with safety checks
+- Develop monitoring and rollback capabilities for production systems
+- Learn domain-specific patterns for development and infrastructure agents
+
+
+ This builds on your Week 2 agent creation skills. You'll need access to GitHub
+ and Vercel accounts with appropriate permissions to complete today's
+ exercises.
+
+
+## Step 1: Understanding development agent patterns
+
+Before building, understand what makes development agents different from
+general-purpose agents:
+
+### Code understanding capabilities
+
+Development agents need to:
+
+- **Analyze code quality** beyond just syntax—understanding patterns, security
+ implications, and performance
+- **Understand project context** from README files, documentation, and code
+ structure
+- **Follow coding standards** specific to languages, frameworks, and team
+ conventions
+- **Assess risk levels** for changes based on file criticality and change scope
+
+### Deployment intelligence
+
+Infrastructure agents must:
+
+- **Coordinate deployments** across environments (development, staging,
+ production)
+- **Monitor build status** and understand when deployments are safe
+- **Implement rollback strategies** when issues are detected
+- **Manage environment variables** and configuration securely
+
+
+ **Domain expertise matters** development agents need to understand not just
+ how to use GitHub and Vercel APIs, but when and why to use specific features
+ based on development best practices.
+
+
+## Step 2: Create your development agent with Concierge
+
+Let's build a sophisticated development agent that combines code management and
+deployment capabilities:
+
+**Start with Concierge:**
+
+```text
+I want to create a development and infrastructure agent that helps me manage code reviews and deployments.
+
+The agent should:
+- Review pull requests on GitHub for code quality, security issues, and best practices
+- Manage deployments to Vercel with proper staging and production workflows
+- Monitor deployment status and performance metrics
+- Coordinate releases between code merges and deployments
+- Provide intelligent insights about code changes and their potential impact
+
+I want it to act like a senior DevOps engineer who understands both code quality and production stability.
+```
+
+### Example agent configuration
+
+Based on the GitHub Review Bot example from the gallery, enhance your agent with
+these capabilities:
+
+**Core responsibilities:**
+
+- Automated code review with actionable feedback
+- Deployment coordination with safety checks
+- Performance monitoring and alerting
+- Release note generation
+- Rollback automation when issues detected
+
+**Key integrations needed:**
+
+- **GitHub**: Repository access, PR management, issue tracking
+- **Vercel**: Deployment management, environment configuration, monitoring
+- **Slack** (optional): Team notifications for important events
+
+## Step 3: Implement intelligent code review workflows
+
+Your development agent should go beyond basic linting. Drawing from the GitHub
+Review Bot example:
+
+**Configure advanced review capabilities:**
+
+```text
+When reviewing pull requests, analyze:
+
+1. Code Quality Patterns:
+ - Clean code principles and readability
+ - DRY (Don't Repeat Yourself) violations
+ - Function complexity and refactoring opportunities
+ - Consistent naming conventions
+
+2. Security Analysis:
+ - Hardcoded secrets or API keys
+ - SQL injection vulnerabilities
+ - Cross-site scripting (XSS) risks
+ - Dependency vulnerabilities
+
+3. Performance Considerations:
+ - Database query optimization
+ - Memory leak potential
+ - Unnecessary re-renders (for React)
+ - Bundle size impact
+
+4. Testing Coverage:
+ - Missing test cases
+ - Edge case handling
+ - Integration test requirements
+
+Provide specific line numbers and code examples for all feedback.
+Use severity levels: Critical, High, Medium, Low.
+Always include positive feedback for well-written code sections.
+```
+
+### Example code review interaction
+
+```text
+You: Review PR #142 in our main repository - it's adding a new authentication system.
+
+Agent: I've completed the review of PR #142 - "Implement OAuth 2.0 authentication system". Here's my analysis:
+
+**Overall Score: 8/10**
+
+**Critical Issues:**
+• Line 45 in auth.js: Hardcoded client secret should be moved to environment variables
+• Line 128 in middleware.js: Missing input validation for JWT tokens could lead to injection attacks
+
+**Security Recommendations:**
+• Add rate limiting to login endpoints (auth.js:67-89)
+• Implement refresh token rotation for enhanced security
+• Consider adding PKCE flow for public clients
+
+**Performance Optimizations:**
+• Token validation is happening on every request - implement caching (middleware.js:34)
+• Database queries in getUserProfile() could be optimized with indexes
+
+**Positive Highlights:**
+• Excellent test coverage at 94%
+• Clean separation of auth and authorization logic
+• Proper error handling without leaking sensitive info
+
+**Deployment Considerations:**
+• Will need to update Vercel environment variables before deployment
+• Database migrations required for refresh_tokens table
+• Consider feature flag for gradual rollout
+
+Ready to proceed with deployment after addressing critical issues.
+```
+
+## Step 4: Automate deployment workflows with Vercel
+
+Now let's add sophisticated deployment capabilities:
+
+**Configure deployment intelligence:**
+
+```text
+For deployment workflows, implement:
+
+1. Pre-deployment Checks:
+ - All CI/CD tests passing
+ - No critical security issues in code review
+ - Database migrations ready if needed
+ - Environment variables configured
+
+2. Staging Deployment First:
+ - Deploy to staging environment
+ - Run smoke tests automatically
+ - Check performance metrics
+ - Verify no errors in logs
+
+3. Production Deployment:
+ - Only after staging validation
+ - Implement canary or blue-green deployment
+ - Monitor error rates and performance
+ - Automatic rollback if error threshold exceeded
+
+4. Post-deployment Monitoring:
+ - Track Core Web Vitals
+ - Monitor error rates
+ - Check API response times
+ - Alert on anomalies
+```
+
+### Example deployment workflow
+
+```text
+You: The PR has been approved. Deploy the authentication changes to production.
+
+Agent: I'll coordinate the deployment of the authentication system to production. Let me start with our safety checks:
+
+**Pre-deployment Validation:**
+✅ All GitHub Actions tests passing (last run: 2 minutes ago)
+✅ Critical security issues from code review have been addressed
+✅ PR #142 merged to main branch
+✅ Vercel preview deployment successful
+
+**Staging Deployment:**
+Deploying to staging environment...
+✅ Deployment successful: https://app-staging.vercel.app
+✅ Running automated smoke tests...
+ - Login flow: PASS (avg 230ms)
+ - Token refresh: PASS (avg 145ms)
+ - Logout flow: PASS (avg 89ms)
+✅ No errors in staging logs (monitored for 5 minutes)
+
+**Production Deployment Plan:**
+I'll use a canary deployment strategy:
+1. Deploy to 10% of traffic first
+2. Monitor for 15 minutes
+3. If metrics are stable, deploy to 100%
+
+Shall I proceed with the canary deployment to production?
+
+[After confirmation]
+
+**Production Deployment Progress:**
+🚀 Deploying to production (10% canary)...
+✅ Canary deployment live
+📊 Monitoring metrics for 15 minutes...
+ - Error rate: 0.01% (baseline: 0.02%) ✅
+ - Response time: 122ms (baseline: 118ms) ✅
+ - CPU usage: 34% (baseline: 32%) ✅
+
+All metrics look healthy. Promoting to 100% traffic...
+✅ Full production deployment complete!
+
+**Deployment Summary:**
+- URL: https://app.vercel.app
+- Build ID: dpl_Fk3j2k4j2k3j4
+- Duration: 18 minutes total
+- Features: OAuth 2.0 authentication system
+
+**Next Steps:**
+1. Monitor error rates for next 24 hours
+2. Review user feedback on new auth flow
+3. Plan gradual feature flag rollout for existing users
+
+I'll continue monitoring and alert you if any issues arise.
+```
+
+## Step 5: Create development best practices automation
+
+Extend your agent to enforce and automate development best practices:
+
+**Advanced automation patterns:**
+
+```text
+Implement these automated workflows:
+
+1. Dependency Management:
+ - Weekly dependency update PRs
+ - Security vulnerability scanning
+ - Breaking change detection
+ - Automated testing of updates
+
+2. Documentation Sync:
+ - Update API docs when endpoints change
+ - Generate changelog from PR descriptions
+ - Keep README synchronized with actual setup
+ - Create architecture diagrams from code
+
+3. Performance Budget Enforcement:
+ - Block deployments exceeding bundle size limits
+ - Warn on significant performance regressions
+ - Track and report Core Web Vitals trends
+ - Suggest optimization opportunities
+
+4. Release Coordination:
+ - Generate release notes from merged PRs
+ - Coordinate database migrations with deployments
+ - Manage feature flags for gradual rollouts
+ - Schedule deployments for optimal times
+```
+
+## What you've accomplished
+
+In 30 minutes, you've built a sophisticated development and infrastructure agent
+that:
+
+**Code intelligence** reviews code with understanding of quality, security, and
+performance implications beyond basic syntax
+
+**Deployment orchestration** manages complex deployment workflows with staging
+validation, canary releases, and automatic rollbacks
+
+**Production monitoring** tracks system health, detects anomalies, and takes
+corrective action when needed
+
+**Best practices automation** enforces development standards, manages
+dependencies, and coordinates releases
+
+**Domain expertise** acts like a senior DevOps engineer, understanding not just
+how to use tools but when and why
+
+## The power of domain-specific development agents
+
+Development agents that truly understand code and infrastructure can:
+
+**Reduce deployment risk** catch issues before they reach production through
+intelligent analysis
+
+**Accelerate development** automate repetitive tasks while maintaining quality
+standards
+
+**Improve code quality** provide consistent, actionable feedback on every change
+
+**Enable continuous deployment** safe, automated releases with confidence
+
+**Scale expertise** every developer gets access to senior-level DevOps knowledge
+
+
+ Data & Analytics with Neo4j and MongoDB. Build agents that understand graph
+ relationships and document structures for complex data analysis.
+
+
+## Pro tip for today
+
+After building your development agent, test it with real scenarios:
+
+```text
+What development workflows in our team are most error-prone or time-consuming?
+How can we enhance your capabilities to better handle these specific patterns?
+```
+
+This helps you identify additional automation opportunities specific to your
+team's needs.
+
+---
+
+**Time to complete** ~30 minutes
+
+**Skills learned** code review intelligence, deployment orchestration,
+production monitoring, rollback automation, development best practices
+
+**Next** day 13 - Data & Analytics agents with Neo4j and MongoDB
+
+
+ **Remember** the best development agents don't just execute commands—they
+ understand the why behind development practices and make intelligent decisions
+ about code quality, deployment safety, and system reliability.
+
diff --git a/agents/30-days-of-agents/day-13.mdx b/agents/30-days-of-agents/day-13.mdx
new file mode 100644
index 00000000..2f65f1ed
--- /dev/null
+++ b/agents/30-days-of-agents/day-13.mdx
@@ -0,0 +1,210 @@
+---
+title: "Day 13: Project Management & Documentation - Linear & Notion"
+sidebarTitle: "Day 13: Linear & Notion"
+description:
+ "Build a project management agent that coordinates tasks, tracks progress, and
+ maintains documentation across Linear and Notion."
+---
+
+
+ **Goal**: create a project coordination agent with Linear and Notion
+
+**Theme**: domain specialization week - project intelligence
+
+**Time investment**: ~20 minutes
+
+
+
+Welcome to Day 13! Today you'll build a **project management agent** that
+bridges task tracking in Linear with documentation in Notion. This agent
+understands how modern teams work across multiple tools.
+
+## What you'll accomplish today
+
+- Build a project management agent that coordinates across tools
+- Connect Linear for issue tracking and sprint management
+- Integrate Notion for documentation and knowledge management
+- Create workflows that keep projects and docs in sync
+
+
+ You'll need access to Linear and Notion workspaces with appropriate
+ permissions to complete today's exercises.
+
+
+## Step 1: Understanding project management patterns
+
+Project agents need to understand:
+
+### Cross-tool coordination
+
+- **Task lifecycle**: From idea in Notion → issue in Linear → documentation
+ update
+- **Status synchronization**: Keep project status consistent across platforms
+- **Knowledge capture**: Document decisions and outcomes, not just track tasks
+- **Team collaboration**: Different tools for different team members
+
+
+ **Multi-tool thinking**: your agent should understand that Linear tracks work
+ while Notion captures knowledge—and keep both synchronized.
+
+
+## Step 2: Create your project management agent
+
+Work with Concierge to build a cross-platform coordinator:
+
+```text
+I want to create a project management agent that coordinates between Linear and Notion.
+
+The agent should:
+- Track sprint progress in Linear and update project docs in Notion
+- Create Linear issues from Notion meeting notes and planning docs
+- Generate weekly project summaries combining task data and documentation
+- Ensure technical decisions in Linear are documented in Notion
+- Keep project roadmaps synchronized across both platforms
+
+It should act like a technical project manager who ensures nothing falls through the cracks.
+```
+
+## Step 3 connect Linear and Notion
+
+Add both connections to your agent:
+
+**Linear connection**:
+
+- Issue management and creation
+- Sprint tracking and velocity
+- Project status and milestones
+- Team workload visibility
+
+**Notion connection**:
+
+- Documentation reading and updates
+- Meeting notes processing
+- Knowledge base management
+- Project wiki maintenance
+
+## Step 4: Implement coordination workflows
+
+### Workflow 1: Sprint documentation
+
+```text
+At the end of each sprint, can you:
+1. Summarize completed Linear issues
+2. Extract key decisions and technical changes
+3. Update our Notion sprint retrospective doc
+4. Identify undocumented features that need wiki updates
+```
+
+Your agent coordinates:
+
+- Pulls completed issues from Linear
+- Identifies important decisions and changes
+- Updates Notion with structured summaries
+- Flags documentation gaps
+
+### Workflow 2: Meeting to task conversion
+
+```text
+I just finished a planning meeting. The notes are in Notion under "Product Planning."
+Can you create Linear issues for all the action items we discussed?
+```
+
+The agent:
+
+- Reads meeting notes from Notion
+- Identifies concrete action items
+- Creates properly labeled Linear issues
+- Links back to source documentation
+
+## Step 5: Build reusable coordination tasks
+
+
+ **Coming soon** daily scheduled tasks and automated workflows. For now, you'll
+ need to interact with your agent through the UI to trigger these workflows.
+
+
+**Daily standup prep**:
+
+```text
+Can you prepare a standup summary that includes:
+- Yesterday's completed Linear issues
+- Today's priorities from Linear
+- Any blockers mentioned in Linear comments
+- Related Notion docs for context
+
+Post this in our Notion daily standups page.
+```
+
+**Documentation health check**:
+
+```text
+Can you analyze:
+- Linear issues marked "Done" without linked documentation
+- Notion pages that reference outdated Linear issues
+- Technical decisions in Linear not captured in Notion
+- Project timelines that have diverged between tools
+
+Create a "Documentation Debt" report in Notion.
+```
+
+
+ **Pro tip** set a reminder to run these workflows daily or weekly until
+ automated scheduling becomes available.
+
+
+## What you've accomplished
+
+In 20 minutes, you've built a cross-platform project management agent:
+
+**Multi-tool coordination** agent that understands Linear for execution and
+Notion for knowledge
+
+**Manual synchronization** keeps tasks and documentation aligned when you run
+the workflows
+
+**Workflow intelligence** converts between different information formats
+
+**Gap identification** finds where documentation doesn't match execution
+
+## The power of multi-tool agents
+
+Project management agents that span tools can:
+
+- **Prevent information silos** by connecting execution with documentation
+- **Reduce context switching** by bringing information together
+- **Capture institutional knowledge** automatically from task execution
+- **Improve team alignment** through consistent cross-tool updates
+
+
+ Data & analytics with Neo4j and MongoDB. Build agents that understand complex
+ data relationships.
+
+
+## Pro tip for today
+
+Ask your project agent:
+
+```text
+What patterns do you notice between our Linear velocity and our Notion documentation quality?
+How can we improve both?
+```
+
+This helps your agent develop insights about your team's work patterns.
+
+---
+
+**Time to complete**: ~20 minutes
+
+**Skills learned** multi-tool coordination, Linear integration, Notion
+automation, project intelligence
+
+**Next** Day 14 - Data & analytics agents with Neo4j and MongoDB
+
+
+ **Remember** the best project agents don't just move data between tools—they
+ understand how your team works and help improve processes.
+
diff --git a/agents/30-days-of-agents/day-14.mdx b/agents/30-days-of-agents/day-14.mdx
new file mode 100644
index 00000000..84492438
--- /dev/null
+++ b/agents/30-days-of-agents/day-14.mdx
@@ -0,0 +1,219 @@
+---
+title: "Day 14: Data & Analytics Intelligence - Neo4j & MongoDB"
+sidebarTitle: "Day 14: Neo4j & MongoDB"
+description:
+ "Build data analysis agents that understand graph relationships in Neo4j and
+ document structures in MongoDB for complex business intelligence."
+---
+
+
+ **Goal**: create data intelligence agents for graph and document databases
+
+**Theme**: domain specialization week - data & analytics
+
+**Time investment**: ~20 minutes
+
+
+
+Welcome to Day 14! Today you'll build **data intelligence agents** that work
+with modern databases—Neo4j for graph relationships and MongoDB for document
+structures. These agents understand complex data patterns, not just queries.
+
+## What you'll accomplish today
+
+- Build agents that understand graph relationships and document structures
+- Connect Neo4j for relationship analysis and pattern detection
+- Integrate MongoDB for flexible document querying
+- Create insights from complex, interconnected data
+
+
+ You'll need access to Neo4j and/or MongoDB instances to complete today's
+ hands-on exercises. The concepts apply to any modern database.
+
+
+## Step 1: Understanding modern data patterns
+
+Data intelligence agents must grasp:
+
+### Graph intelligence Neo4j
+
+- **Relationship mapping**: How entities connect and influence each other
+- **Pattern detection**: Finding hidden connections in networks
+- **Path analysis**: Shortest paths, influence chains, impact radius
+- **Community detection**: Clusters, groups, and anomalies
+
+### Document intelligence MongoDB
+
+- **Schema flexibility**: Varying document structures and embedded data
+- **Aggregation patterns**: Complex queries across nested documents
+- **Time-series analysis**: Historical patterns and trends
+- **X insights**: Location-based patterns and relationships
+
+
+ **Beyond SQL thinking** modern data agents understand relationships and
+ document structures, not just tables and rows.
+
+
+## Step 2: Create specialized data agents
+
+### Graph intelligence agent (Neo4j)
+
+```text
+I want to create a customer intelligence agent using our Neo4j graph database.
+
+The agent should:
+- Analyze customer relationship networks and referral chains
+- Identify influential customers based on connection patterns
+- Find communities and clusters in our user base
+- Detect unusual relationship patterns that might indicate fraud
+- Recommend connections that could drive growth
+
+Think like a network analyst who understands social dynamics and graph theory.
+```
+
+### Document analytics agent (MongoDB)
+
+```text
+I want to create a product analytics agent using our MongoDB database.
+
+The agent should:
+- Analyze product usage patterns across different user segments
+- Track feature adoption through nested event documents
+- Identify user journeys from unstructured activity logs
+- Find patterns in customer feedback and support tickets
+- Generate insights from varying document schemas
+
+Think like a data scientist working with semi-structured data.
+```
+
+## Step 3: Connect and explore your databases
+
+### Neo4j connection capabilities
+
+Your agent can:
+
+- **Traverse relationships**: Follow connections multiple degrees deep
+- **Find patterns**: Match complex relationship structures
+- **Calculate centrality**: Identify important nodes in networks
+- **Detect communities**: Find natural groupings and clusters
+
+### MongoDB connection capabilities
+
+Your agent can:
+
+- **Query nested documents**: Access deeply embedded data
+- **Aggregate flexibly**: Group, filter, and transform documents
+- **Handle variety**: Work with different document structures
+- **Process time-series**: Analyze temporal patterns
+
+## Step 4: Implement data intelligence workflows
+
+### Graph analysis example (Neo4j)
+
+```text
+Who are our most influential customers based on referral networks?
+How can we leverage these relationships for growth?
+```
+
+Your agent analyzes:
+
+- Referral chains and their success rates
+- Network effects from key customers
+- Community structures and growth patterns
+- Opportunities for connection strategies
+
+### Document analysis example (MongoDB)
+
+```text
+What user behavior patterns predict successful feature adoption?
+Which segments are struggling with our new features?
+```
+
+Your agent examines:
+
+- Feature usage sequences in activity logs
+- Correlation between user properties and adoption
+- Time-to-value patterns across segments
+- Drop-off points in user journeys
+
+## Step 5: Create advanced data workflows
+
+**Network health monitoring** (Neo4j):
+
+```text
+Weekly, analyze our customer network for:
+- Growing communities that might need dedicated support
+- Isolated users who could benefit from connections
+- Referral chains that have gone cold
+- Emerging influencers based on connection growth
+
+Provide actionable recommendations for community management.
+```
+
+**Behavioral intelligence** (MongoDB):
+
+```text
+Daily, process user activity documents to identify:
+- Unusual usage patterns indicating potential issues
+- Feature combinations that drive engagement
+- User segments with declining activity
+- Success patterns we should replicate
+
+Focus on actionable insights, not just statistics.
+```
+
+## What you've accomplished
+
+In 20 minutes, you've built sophisticated data intelligence agents:
+
+**Graph understanding** Agents that see relationships, not just data points
+
+**Document flexibility** working with varied, nested, and complex structures
+
+**Pattern recognition** finding insights in connected and unstructured data
+
+**Actionable intelligence** recommendations based on data patterns, not just
+queries
+
+## The power of modern data agents
+
+Data agents that understand modern databases can:
+
+- **Reveal hidden connections** in relationship networks
+- **Find patterns in chaos** of unstructured documents
+- **Predict behaviors** from historical patterns
+- **Enable data democracy** without query language expertise
+
+
+ Customer relationship management with Attio and Google Sheets. Build agents
+ for sales intelligence and spreadsheet automation.
+
+
+## Pro tip for today
+
+Challenge your data agents:
+
+```text
+What non-obvious patterns in our data could give us a competitive advantage?
+Show me connections or trends I wouldn't think to look for.
+```
+
+This pushes agents beyond basic queries to true intelligence.
+
+---
+
+**Time to complete**: ~20 minutes
+
+**Skills learned** graph database intelligence, document database analytics,
+pattern recognition, modern data workflows
+
+**Next** Day 15 - CRM and spreadsheet intelligence with Attio and Google Sheets
+
+
+ **Remember** the best data agents don't just run queries—they understand the
+ meaning behind the data and find patterns humans might miss.
+
diff --git a/agents/30-days-of-agents/day-15.mdx b/agents/30-days-of-agents/day-15.mdx
new file mode 100644
index 00000000..53671da9
--- /dev/null
+++ b/agents/30-days-of-agents/day-15.mdx
@@ -0,0 +1,216 @@
+---
+title: "Day 15: Customer Intelligence & Data Operations - Attio & Google Sheets"
+sidebarTitle: "Day 15: Attio & Google Sheets"
+description:
+ "Build sales intelligence agents that manage CRM data in Attio and operational
+ data in Google Sheets, creating unified customer insights and automated
+ workflows."
+---
+
+
+ **Goal**: create customer intelligence agents with CRM and spreadsheet mastery
+
+**Theme**: domain specialization week - customer & operational intelligence
+
+**Time investment**: ~20 minutes
+
+
+
+Welcome to Day 15! You'll complete Week 3 by building **customer intelligence
+agents** that bridge modern CRM (Attio) with operational spreadsheets (Google
+Sheets). These agents transform disconnected data into unified customer
+insights.
+
+## What you'll accomplish today
+
+- Build agents that understand customer relationships and sales processes
+- Connect Attio for modern CRM intelligence
+- Integrate Google Sheets for operational data and reporting
+- Create unified views across sales and operational systems
+
+
+ You'll need access to Attio and Google Sheets to complete today's exercises.
+ The patterns apply to any CRM and spreadsheet combination.
+
+
+## Step 1: Understanding customer intelligence patterns
+
+Customer intelligence agents must understand:
+
+### CRM intelligence (Attio)
+
+- **Relationship mapping**: Companies, contacts, and their interactions
+- **Pipeline dynamics**: Deal flow, conversion rates, and bottlenecks
+- **Activity patterns**: What actions correlate with successful outcomes
+- **Data enrichment**: Combining CRM data with external intelligence
+
+### Operational intelligence (Google sheets)
+
+- **Flexible reporting**: Custom metrics and calculations
+- **Data bridging**: Information that lives outside the CRM
+- **Historical tracking**: Trends and patterns over time
+- **Team accessibility**: Shared operational dashboards
+
+
+ **Unified thinking** your agent should understand that CRMs track
+ relationships while spreadsheets often contain the operational truth.
+
+
+## Step 2: Create customer intelligence agents
+
+Work with Concierge to build a unified intelligence agent:
+
+```text
+I want to create a customer intelligence agent that works with Attio and Google Sheets.
+
+The agent should:
+- Monitor deal pipeline in Attio and update forecasting sheets
+- Enrich CRM data with operational metrics from spreadsheets
+- Generate unified customer health scores combining both sources
+- Alert on mismatches between CRM pipeline and operational data
+- Create executive dashboards that merge relationship and operational insights
+
+It should think like a revenue operations analyst who sees the full picture.
+```
+
+## Step 3: Connect Attio and Google Sheets
+
+### Attio capabilities
+
+Your agent can:
+
+- **Manage relationships**: Create and update companies, contacts, deals
+- **Track activities**: Log interactions, meetings, and touchpoints
+- **Analyze pipelines**: Deal stages, conversion rates, and velocity
+- **Custom attributes**: Work with your specific data model
+
+### Google sheets capabilities
+
+Your agent can:
+
+- **Read/write data**: Update cells, ranges, and formulas
+- **Create reports**: Generate new sheets with formatted data
+- **Process calculations**: Run complex operational metrics
+- **Maintain history**: Track changes over time
+
+## Step 4: Implement unified workflows
+
+### Workflow 1: Pipeline-to-forecast synchronization
+
+```text
+Can you analyze our current Attio pipeline and update our revenue forecast sheet?
+Include deal probability based on stage and historical conversion rates.
+```
+
+Your agent:
+
+- Pulls current pipeline from Attio
+- Calculates weighted revenue by stage
+- Updates forecast spreadsheet with breakdown
+- Highlights changes from last update
+
+### Workflow 2: Customer health scoring
+
+```text
+Create a unified customer health score combining:
+- Attio: engagement frequency, deal value, relationship strength
+- Sheets: product usage, support tickets, payment history
+
+Identify at-risk accounts that need attention.
+```
+
+The agent:
+
+- Merges relationship data with operational metrics
+- Calculates composite health scores
+- Flags accounts with declining indicators
+- Suggests intervention strategies
+
+## Step 5: Build automated intelligence tasks
+
+**Weekly sales intelligence report**:
+
+```text
+Every Monday, create a sales intelligence report that:
+1. Summarizes pipeline changes in Attio
+2. Updates win rate calculations in our metrics sheet
+3. Identifies deals stuck in stages too long
+4. Compares CRM pipeline to operational forecasts
+5. Highlights data discrepancies needing cleanup
+
+Format for our executive team meeting.
+```
+
+**Customer success automation**:
+
+```text
+Daily, monitor for:
+- New deals closed in Attio → Create onboarding checklist in Sheets
+- Usage drops in Sheets data → Update account status in Attio
+- Support tickets in Sheets → Log activities in Attio
+- Payment issues in Sheets → Flag deals at risk in Attio
+
+Keep both systems synchronized for accurate customer view.
+```
+
+## What you've accomplished
+
+In 20 minutes, you've built comprehensive customer intelligence:
+
+**Unified data view** agents that bridge CRM and operational data
+
+**Automated synchronization** keep multiple systems aligned automatically
+
+**Intelligent insights** combine relationship and operational intelligence
+
+**Proactive alerts** catch issues before they impact revenue
+
+## Week 3 complete: Domain specialization achieved
+
+You've completed Week 3 and mastered domain-specific agent development:
+
+- **Day 11**: Financial intelligence with Stripe
+- **Day 12**: Development workflows with GitHub and Vercel
+- **Day 13**: Project coordination with Linear and Notion
+- **Day 14**: Data analytics with Neo4j and MongoDB
+- **Day 15**: Customer intelligence with Attio and Google Sheets
+
+## The power of domain expertise
+
+Your agents now:
+
+- **Understand business context**, not just tool APIs
+- **Think like domain experts** in their specialized areas
+- **Connect disparate systems** into unified intelligence
+- **Provide actionable insights**, not just data movement
+
+
+ **Production deployment and optimization** - Take your agents from development
+ to business-critical production systems with monitoring, scaling, and
+ performance optimization.
+
+
+## Pro tip for Week 3
+
+Ask any of your domain agents:
+
+```text
+What patterns have you noticed that could fundamentally change how we operate?
+What would a 10x improvement look like in your domain?
+```
+
+This pushes agents beyond automation to transformation.
+
+---
+
+**Time to complete** ~20 minutes
+
+**Skills learned** CRM intelligence, spreadsheet automation, unified customer
+view, cross-system synchronization
+
+**Week 3 complete** you're now a domain-specific agent builder!
+
+
+ **Remember** the best domain agents don't just use tools—they embody the
+ expertise and judgment of seasoned professionals in their field.
+
diff --git a/agents/30-days-of-agents/domain-specific-agents.mdx b/agents/30-days-of-agents/domain-specific-agents.mdx
new file mode 100644
index 00000000..443ec32c
--- /dev/null
+++ b/agents/30-days-of-agents/domain-specific-agents.mdx
@@ -0,0 +1,79 @@
+---
+title: "Week 3: Domain-Specific Agents"
+sidebarTitle: "Choose your path"
+description:
+ "Dive into domain-specific agents. Learn how to build agents tailored to
+ specific tasks and industries, enhancing their effectiveness and efficiency."
+---
+
+
+
+Welcome to Week 3! You've mastered the fundamentals with Sidekick and built
+custom agents with Concierge. Now it's time to **specialize**.
+
+This week focuses on domain-specific agents—AI that understands the nuances of
+specific business functions and tools. You'll learn to build agents that don't
+just use tools, but truly understand the workflows and best practices of
+different domains.
+
+## Choose your learning path
+
+Week 3 offers **specialized domain tracks** based on your role and interests.
+You can follow domains that match your work, or complete multiple tracks to
+become an **Agent Super Builder**.
+
+
+
+ **Day 11 Stripe Integration**
+
+ Build agents that handle payments, subscriptions, and financial workflows with deep business intelligence.
+
+ *Perfect for: Revenue Operations, Finance Teams, SaaS Businesses*
+
+
+
+
+ **Day 12 GitHub & Vercel Integration** Create agents that manage code
+ repositories, deployments, and development workflows with engineering
+ expertise.
+
+Perfect for developers, DevOps teams, Platform engineers
+
+
+
+
+ **Day 13 Linear & Notion Integration** Build agents that coordinate tasks,
+ track progress, and maintain documentation across project tools.
+
+Perfect for project managers, engineering teams, product teams
+
+
+
+
+ **Day 14 Neo4j & MongoDB Integration** Build agents that work with graph
+ databases and document stores for complex data analysis and insights.
+
+Perfect for: data engineers, analytics teams, backend developers
+
+
+
+
+ **Day 15 Attio CRM & Google Sheets Integration**
+ Develop agents that manage customer relationships and operational data for unified business intelligence.
+
+Perfect for: sales Teams, Customer Success, Revenue Operations
+
+
+
diff --git a/docs.json b/docs.json
index 1621e380..cd378c08 100644
--- a/docs.json
+++ b/docs.json
@@ -107,6 +107,17 @@
"agents/30-days-of-agents/day-9",
"agents/30-days-of-agents/day-10"
]
+ },
+ {
+ "group": "Week 3",
+ "pages": [
+ "agents/30-days-of-agents/domain-specific-agents",
+ "agents/30-days-of-agents/day-11",
+ "agents/30-days-of-agents/day-12",
+ "agents/30-days-of-agents/day-13",
+ "agents/30-days-of-agents/day-14",
+ "agents/30-days-of-agents/day-15"
+ ]
}
]
},
diff --git a/styles/config/vocabularies/general/accept.txt b/styles/config/vocabularies/general/accept.txt
index 4c92d7c8..57a0ea7a 100644
--- a/styles/config/vocabularies/general/accept.txt
+++ b/styles/config/vocabularies/general/accept.txt
@@ -183,4 +183,15 @@ I'm
GTM
chatbots
enablement
-[lL]uma
\ No newline at end of file
+[lL]uma
+CRM
+CRMs
+touchpoints
+Neo4j
+Geospatial
+Linear
+MRR
+LTV
+CAC
+upsell
+will
\ No newline at end of file