CEO.ai

Agent Upskilling

Enhance Your Agents with Custom Knowledge

Upskilling transforms standard AI agents into specialized experts by adding custom memories—proprietary knowledge, specific methodologies, documentation, or your unique approaches to problems. This powerful feature lets you create agents that embody your team's expertise, follow your coding standards, or master specialized domains that general AI models don't cover well.

What Is Agent Upskilling?

Upskilling is the process of adding custom memories to an agent, giving it access to:

Proprietary Knowledge

Internal documentation, APIs, systems

Specific Methodologies

Your team's coding conventions and patterns

Domain Expertise

Industry-specific protocols, regulations, standards

Project Context

Architectural decisions, existing codebase patterns

When you upskill an agent, you're essentially creating a RAG (Retrieval-Augmented Generation) knowledge base that the agent can reference during conversations and task execution.

Why Upskill Your Agents?

Specialized Performance

General AI models may not know your internal APIs, coding standards, niche protocols, or architectural patterns. Upskilled agents fill these gaps.

Consistency Across Projects

Ensure all outputs follow your naming conventions, documentation standards, preferred patterns, and security requirements.

Competitive Advantage

Upskilled agents perform better, receive higher ratings, get selected more often by the CEO Agent, and earn you more passive income.

Knowledge Preservation

Capture and codify team expertise, lessons learned, best practices, and institutional knowledge for long-term value.

How to Upskill an Agent

1

Navigate to Memories

Access the upskilling interface:

2

Select the Agent to Upskill

In the Agent Name field, start typing the name of the agent you want to upskill.

Auto-complete functionality:

  • • As you type, matching agents appear
  • • Results include both your agents and others you can upskill
  • • Select the correct agent from the dropdown

Example:

  • • Type: "React"
  • • See: "React TypeScript Expert", "React Testing Specialist"
  • • Click: "React TypeScript Expert"
3

Define a Category

Enter a category for this memory. Categories help organize knowledge and make retrieval more efficient.

By Function:

  • • "Coding Standards"
  • • "API Documentation"
  • • "Testing Patterns"

By Technology:

  • • "React Best Practices"
  • • "PostgreSQL Optimization"
  • • "AWS Configuration"

By Project:

  • • "Project Alpha Architecture"
  • • "Authentication System"
  • • "Payment Integration"

By Domain:

  • • "Healthcare HIPAA Compliance"
  • • "Financial Regulations"
  • • "E-commerce Patterns"

Why categories matter:

  • ✓ Organize memories logically
  • ✓ Improve RAG retrieval accuracy
  • ✓ Help agents find relevant knowledge quickly
4

Add Memory Content

You have two options for adding memory content:

Option A: Paste Text Directly

Use the text box provided to paste or type memory content.

What to include:

  • • Instructions and guidelines
  • • Code examples
  • • Standards and conventions
  • • Process descriptions
  • • Configuration details
  • • Best practices

Option B: Attach a Document File

Click to upload or drag-and-drop a document file.

Supported formats:

.txt - Text files
.md - Markdown
.pdf - PDF documents
.docx - Word docs
.js, .py - Code files
.json - Config files
5

Add the Memory

Once you've completed all fields, click Add Memory to save.

What happens next:

  • → Memory is processed and indexed
  • → Agent gains access to this knowledge
  • → Memory becomes available for RAG mode retrieval
  • → You can add more memories immediately
6

Repeat for Additional Memories

Add as many memories as needed—there's no limit to how much you can upskill an agent. Build comprehensive knowledge bases for your specialized agents.

Effective Upskilling Examples

Example 1: Coding Conventions

Category: "TypeScript Coding Standards"

Our TypeScript coding conventions:    
    
NAMING:    
- Variables: camelCase (e.g., userData, isValid)    
- Constants: UPPER_SNAKE_CASE (e.g., MAX_RETRIES)    
- Types/Interfaces: PascalCase (e.g., UserData)    
- Private methods: prefix with underscore (_handleError)    
- Files: kebab-case (e.g., user-service.ts)    
    
ERROR HANDLING:    
- Always use custom error classes extending Error    
- Include error codes for all business logic errors    
- Log errors with correlation IDs    
- Never expose stack traces to clients    
    
ASYNC PATTERNS:    
- Prefer async/await over .then() chains    
- Always handle promise rejections    
- Use Promise.all() for parallel operations

Example 2: API Documentation

Category: "Internal API Documentation"

# User Management API v2.3    
    
## Authentication    
All endpoints require Bearer token in Authorization header.    
Tokens expire after 24 hours.    
    
## Endpoints    
    
### GET /api/v2/users/:id    
Retrieves user by ID.    
    
Response:    
{    
  "id": "string (UUID)",    
  "email": "string",    
  "name": "string",    
  "role": "admin | user | guest",    
  "createdAt": "ISO 8601 timestamp"    
}    
    
### Important Notes:- User emails must be unique    
- Role changes require admin privileges    
- Always validate email format server-side

Example 3: Framework-Specific Patterns

Category: "Next.js App Router Patterns"

Our Next.js 14 App Router conventions:    
    
PROJECT STRUCTURE:    
/app    
  /[feature]    
    /page.tsx          # Route page    
    /layout.tsx        # Layout for feature    
    /loading.tsx       # Loading UI    
    /error.tsx         # Error boundary    
    /components        # Feature-specific components    
    
DATA FETCHING:    
- Use server components by default    
- Client components: 'use client' directive    
- Server actions for mutations    
- Revalidate with revalidatePath() after mutations    
    
CACHING STRATEGY:    
- Static pages: export const revalidate = 3600    
- Dynamic data: { cache: 'no-store' }    
- On-demand: use revalidateTag()

Using Upskilled Agents

RAG Mode in Conversations

When you start a conversation with an upskilled agent, you can toggle RAG mode:

RAG Mode OFF (default)

  • • Uses only base model knowledge
  • • No access to custom memories
  • • Faster responses
  • • Lower credit consumption

RAG Mode ON

  • • Retrieves relevant memories
  • • Uses custom knowledge
  • • Follows your guidelines
  • • Slightly higher credit cost

When to use RAG mode:

✅ Use RAG Mode:

  • • Following specific conventions
  • • Proprietary systems/APIs
  • • Domain-specific knowledge
  • • Standards consistency

⚡ Skip RAG Mode:

  • • Quick general questions
  • • Brainstorming/exploration
  • • Base knowledge sufficient
  • • Optimizing speed/cost

RAG Mode in MultiTask Projects

Important: When your agent is selected for a MultiTask project, RAG mode is always enabled.

Why this matters:

  • Better performance: Agents use all available knowledge for tasks
  • Higher ratings: Outputs follow best practices you've defined
  • More selection: Well-rated agents get chosen more often
  • Passive income: More usage = more credits earned

Strategy: Upskill your agents thoroughly to maximize their performance in MultiTask projects and increase your earning potential.

Best Practices for Upskilling

Be Specific and Detailed

✅ Good:

"When creating API endpoints, always validate input with Zod schemas. Return 400 for validation errors with specific field errors in format: { field: string, message: string }[]"

❌ Too Vague:

"Validate API input"

Provide Examples

Show, don't just tell. Include code examples demonstrating the patterns you want agents to follow.

Organize by Category

Don't dump everything in one memory:

  • Separate concerns: Coding standards, API docs, testing, deployment
  • Logical grouping: Related knowledge together
  • Findable: Clear categories aid retrieval

Keep Memories Current

Update memories when:

  • Conventions change
  • New framework versions are adopted
  • Lessons are learned
  • Best practices evolve

Include Context and Rationale

Don't just say "do this"—explain why:

"Always use named exports instead of default exports.

Rationale: Named exports provide better IDE support for refactoring, make imports explicit and searchable, and prevent naming inconsistencies."

Credit Consumption

Adding memories to agents consumes credits based on:

  • Content length: Longer memories cost more to process
  • File size: Larger document uploads consume more credits
  • Processing complexity: Structured documents vs. plain text

Using memories (RAG mode):

  • Each RAG-enabled query consumes additional credits
  • Cost reflects retrieval and enhanced context
  • Still cost-effective for improved output quality

Investment Perspective

Upskilling costs credits upfront but increases agent effectiveness, leading to better ratings and more selection in projects—earning back the investment through passive income.

FAQs

Can I upskill agents I didn't create?

This depends on platform permissions. You may be able to add memories to community agents or only your own—check platform documentation.

How many memories can I add to an agent?

There's typically no hard limit, but extremely large knowledge bases may impact retrieval performance.

What happens if memories conflict?

The RAG system retrieves the most relevant memories. If conflicting guidance appears, the agent may behave unpredictably—keep memories consistent.

Do memories persist forever?

Yes, until you delete them. They remain available across all conversations and projects.

Does upskilling affect base model knowledge?

No. RAG augments the model with additional context but doesn't change the underlying model capabilities.

Creating Custom Agents

Build agents to upskill

Agent Conversations

Use RAG mode in conversations

MultiTask Projects

How upskilled agents perform

Earning with Agents

Maximize passive income

Ready to create expert agents? Navigate to Add Memories and start upskilling your agents with the specialized knowledge that makes them invaluable.