Building BrandGenie: An AI-Powered Brand Identity Generator with Mastra

ALADETAN-IFE — Mon, 03 Nov 2025 22:54:12 +0000

How I built an AI agent that generates complete brand identities including names, taglines, stories, and domain recommendations using Mastra framework
tags: ai, typescript, agents, nodejs

cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/[your-cover-image].png

Building BrandGenie: An AI-Powered Brand Identity Generator

Ever struggled to come up with the perfect brand name for your startup? What if an AI could not only suggest creative names but also check domain availability, write compelling taglines, and craft your brand story—all in seconds?

That's exactly what I built with BrandGenie, an AI branding assistant powered by Mastra and deployed on Telex.

🎯 What is BrandGenie?

Try it here: BrandGenie on Telex

BrandGenie is an AI agent that generates complete brand identity packages. Simply describe your business idea (e.g., "AI-powered fitness coaching app"), and BrandGenie provides:

5 creative, memorable brand names
Domain availability recommendations
A catchy tagline
A compelling brand story
Target audience insights

All formatted in beautiful markdown, ready to use.

🤖 What is Telex?

Telex is an AI agent platform like Zapier or Make.com, but specifically designed for conversational AI workflows. Think of it as a Slack alternative for education, communities, and bootcamps where AI agents can interact with users naturally through chat interfaces.

🛠️ Tech Stack

Backend Framework: Mastra - A modern TypeScript framework for building AI agents
Language Model: Google Gemini 2.5 Flash
Deployment: Mastra Cloud
Integration Platform: Telex (A2A protocol)
Runtime: Node.js with TypeScript

🏗️ Architecture Overview

The application consists of three main components:

Agent - The conversational AI that orchestrates the branding process
Tool - The domain checking and content generation logic
Workflow - Manages the execution flow and data transformation

User Input → Telex → Mastra Cloud → Agent → Tool → Response

📚 Mastra Features Used

1. Agent System

Mastra's Agent system provides the conversational intelligence layer. Here's how I configured BrandGenie:

import { Agent } from '@mastra/core/agent';
import { Memory } from '@mastra/memory';

export const brandGenieAgent = new Agent({
  name: 'BrandGenie Agent',
  instructions: `
    You are an AI branding assistant called BrandGenie.
    Generate 5 creative brand names, then call the brandGenieTool 
    to check domain availability and create a complete brand package.
  `,
  model: 'google/gemini-2.5-flash',
  tools: { brandGenieTool },
  memory: new Memory({
    storage: new LibSQLStore({
      url: 'file:../mastra.db',
    }),
  }),
});

Key Features:

Natural language understanding through LLM integration
Memory system for context retention across conversations
Tool calling capability for domain checking

2. Tool System

Mastra's Tool system allows agents to perform specific actions. My brandGenieTool generates the complete brand identity:

import { createTool } from '@mastra/core/tools';
import { z } from 'zod';

export const brandGenieTool = createTool({
  id: 'brandgenie-tool',
  description: "'Generates complete brand identity package',"
  inputSchema: z.object({
    idea: z.string().describe('Business idea'),
    customNames: z.array(z.string()).optional(),
  }),
  outputSchema: z.object({
    text: z.string().describe('Markdown-formatted brand identity'),
    format: z.literal('markdown'),
  }),
  execute: async ({ context }) => {
    // Industry detection
    const industry = detectIndustry(context.idea);

    // Generate brand names, taglines, and story
    // Return formatted markdown
  },
});

Key Features:

Type-safe input/output validation with Zod schemas
Industry-specific domain recommendations
Structured markdown output

3. Workflow System

Mastra Workflows orchestrate the agent execution:

import { createStep, createWorkflow } from '@mastra/core/workflows';

const generateBranding = createStep(brandGenieAgent);

const brandGenieWorkflow = createWorkflow({
  id: 'brandgenie-workflow',
  inputSchema: z.object({
    idea: z.string(),
  }),
  outputSchema: z.object({
    text: z.string(),
  }),
})
  .map(async ({ inputData }) => ({
    prompt: `Generate brand names for: ${inputData.idea}`
  }))
  .then(generateBranding)
  .commit();

Key Features:

Declarative workflow definition
Data transformation between steps
Type-safe execution pipeline

4. Observability & Logging

Mastra's built-in observability helps monitor agent performance:

export const mastra = new Mastra({
  agents: { brandGenieAgent },
  workflows: { brandGenieWorkflow },
  logger: new PinoLogger({
    name: 'Mastra',
    level: 'info',
  }),
  observability: {
    default: { enabled: true },
  },
});

5. A2A Protocol Integration

For Telex integration, I implemented Mastra's A2A (Agent-to-Agent) protocol:

import { registerApiRoute } from "@mastra/core/server";

export const a2aAgentRoute = registerApiRoute("/a2a/agent/:agentId", {
  method: "POST",
  handler: async (c) => {
    const mastra = c.get("mastra");
    const agentId = c.req.param("agentId");
    const body = await c.req.json();

    // JSON-RPC 2.0 format handling
    const agent = mastra.getAgent(agentId);
    const response = await agent.generate(messages);

    // Return A2A-compliant response
  },
});

6. Scoring System

Implemented custom LLM-as-judge scorer to evaluate brand creativity:

import { createScorer } from '@mastra/core/scores';

export const creativityScorer = createScorer({
  name: 'Brand Creativity & Relevance',
  type: 'agent',
  judge: {
    model: 'google/gemini-2.5-flash',
    instructions: 'Evaluate brand name creativity and relevance...',
  },
})
  .analyze({
    outputSchema: z.object({
      creative: z.boolean(),
      relevant: z.boolean(),
      professional: z.boolean(),
    }),
  })
  .generateScore(({ results }) => {
    // Calculate creativity score
  });

🎨 Domain Detection Logic

One interesting challenge was detecting the right domain extensions for different industries:

const DOMAIN_PRESETS: Record<string, string[]> = {
  tech: ['.com', '.io', '.dev', '.ai', '.co'],
  ecommerce: ['.com', '.shop', '.store', '.co', '.ng'],
  education: ['.edu.ng', '.org', '.academy', '.com'],
  finance: ['.com', '.finance', '.co', '.biz'],
  // ... more industries
};

function detectIndustry(idea: string): string {
  const text = idea.toLowerCase();
  if (text.includes('tech') || text.includes('software')) return 'tech';
  if (text.includes('ecommerce') || text.includes('store')) return 'ecommerce';
  // ... more detection logic
  return 'default';
}

🚀 Deployment & Integration

Deploying to Mastra Cloud

# Deploy the agent
mastra deploy

# Verify deployment
curl https://brandgenie.mastra.cloud/health

Connecting to Telex

Telex integration uses JSON configuration:

{
  "active": true,
  "category": "utilities",
  "name": "brandgenie_agent",
  "description": "Generates creative brand names and checks domain availability",
  "nodes": [{
    "id": "brandgenie_agent_node",
    "name": "BrandGenie Agent",
    "type": "a2a/mastra-a2a-node",
    "url": "https://brandgenie.mastra.cloud/a2a/agent/brandGenieAgent"
  }]
}

🎯 Key Learnings

1. Type Safety is Critical

Mastra's integration with Zod made schema validation seamless and caught many bugs early.

2. Tool Design Matters

Initially, I tried checking domain availability via external APIs, which caused timeouts. Switching to intelligent suggestions without real-time checking improved performance dramatically.

3. Agent Instructions are Code

Clear, detailed instructions in the agent configuration directly impact output quality. Treat them like critical business logic.

4. A2A Protocol Standardizes AI Communication

Using the A2A protocol made integration with Telex straightforward and could enable future integrations with other platforms.

📊 Performance Optimization

Before:

Domain checking: 100+ API calls
Response time: 5-8 minutes ❌

After:

Smart domain suggestions
Response time: 2-3 seconds ✅

The key was moving from real-time domain checking to intelligent recommendations based on industry patterns.

🔮 Future Enhancements

Logo Generation - Integrate DALL-E for brand logo concepts
Color Palette Suggestions - AI-powered brand color schemes
Social Media Handles - Check Twitter, Instagram availability
Competitor Analysis - Research similar brand names
Multi-language Support - Generate names in different languages

💡 Why Mastra?

After trying several AI frameworks, here's why Mastra stood out:

TypeScript-first - Great DX with full type safety
Batteries included - Agent, tools, workflows, memory, scoring all integrated
Production-ready - Built-in observability and logging
Cloud deployment - One command to deploy
A2A protocol - Standards-based agent communication

🎓 Lessons for AI Agent Builders

Start with clear use cases - Don't build a general chatbot; solve specific problems
Design for latency - Users expect fast responses; optimize early
Use structured output - Markdown formatting makes AI responses more useful
Implement graceful degradation - Handle API failures elegantly
Monitor and iterate - Use scoring and observability to improve over time

🔗 Resources

Try BrandGenie: BrandGenie
Telex Platform: telex.im - An AI agent platform like Make.com for conversational workflows
Mastra Documentation: mastra.ai/docs
GitHub Repository: [Your Repo Link]
Mastra Cloud: mastra.ai/cloud

🙋‍♂️ About the Project

BrandGenie started as a learning project to explore AI agent development but evolved into a practical tool for entrepreneurs and marketers. The combination of Mastra's powerful framework and Telex's distribution platform made it possible to go from idea to production in just a few days.

💬 Try It Yourself

Want to build your own AI agent? Here's a quick start:

npm install @mastra/core
npx mastra init

Then follow the Mastra documentation to create your first agent!

What would you build with an AI agent framework? Drop your ideas in the comments! 👇

If you found this helpful, consider giving it a ❤️ and following me for more AI and backend development content.

AI #TypeScript #Agents #Mastra #Backend #Hng #Hng13

DEV Community: ALADETAN-IFE

Building BrandGenie: An AI-Powered Brand Identity Generator with Mastra

cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/[your-cover-image].png

Building BrandGenie: An AI-Powered Brand Identity Generator

🎯 What is BrandGenie?

🤖 What is Telex?

🛠️ Tech Stack

🏗️ Architecture Overview

📚 Mastra Features Used

1. Agent System

2. Tool System

3. Workflow System

4. Observability & Logging

5. A2A Protocol Integration

6. Scoring System

🎨 Domain Detection Logic

🚀 Deployment & Integration

Deploying to Mastra Cloud

Connecting to Telex

🎯 Key Learnings

1. Type Safety is Critical

2. Tool Design Matters

3. Agent Instructions are Code

4. A2A Protocol Standardizes AI Communication

📊 Performance Optimization

Before:

After:

🔮 Future Enhancements

💡 Why Mastra?

🎓 Lessons for AI Agent Builders

🔗 Resources

🙋‍♂️ About the Project

💬 Try It Yourself

AI #TypeScript #Agents #Mastra #Backend #Hng #Hng13