AskTable Skill System: Enabling AI Agents to Call Professional Capabilities on Demand

AskTable is redefining the boundary of AI Agent capabilities. The newly introduced Skill system transforms agents from fixed capability collections into intelligent bodies that can dynamically invoke professional skills based on scenarios. This article deeply analyzes this system's architecture design and implementation principles.

---

I. Why the Skill System Is Needed

1.1 Limitations of Traditional Agents

Traditional AI agents typically compile all capabilities into system prompts or tool lists:

• •Capability solidification: New capabilities require code changes and redeployment
• •Context pollution: Massive tools included in every request, increasing reasoning costs
• •No reuse: Capabilities can't be shared between different agents

1.2 The Skill System Solution

┌─────────────────────────────────────────────────────────────┐
│                    AskTable Skill System                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   ┌─────────┐    ┌─────────┐    ┌─────────┐               │
│   │ Skill 1 │    │ Skill 2 │    │ Skill N │    ← Project-level Skill Library │
│   │ Sales analysis│  │ Financial report│  │ User profiling│               │
│   └────┬────┘    └────┬────┘    └────┬────┘               │
│        │              │              │                      │
│        └──────────────┼──────────────┘                     │
│                       ▼                                    │
│            ┌─────────────────────┐                          │
│            │   Skill Loader      │   ← Three-layer loading mechanism          │
│            │  explicit > agent > project                   │
│            └─────────────────────┘                          │
│                       │                                     │
│                       ▼                                     │
│            ┌─────────────────────┐                          │
│            │  activate_skill()  │   ← On-demand activation              │
│            │  Dynamic tool registration         │                          │
│            └─────────────────────┘                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Core idea: Transform skills from compile-time decisions to runtime selections.

---

II. Skill System Architecture

2.1 Data Model

Skill's data model is clean and efficient:

class SkillModel(Base):
    id: UUID                          # Skill unique identifier
    project_id: str                   # Project affiliation
    name: str                          # Skill name
    description: str                  # Skill description (for agent understanding)
    content: str                       # Skill instruction content
    created_at: datetime
    modified_at: datetime

Design points:

• •project_id implements project-level isolation
• •content is plain text storing skill instructions (similar to system prompt fragments)
• •Supports CRUD, manageable via API or UI

2.2 Association Mechanism

Skills associate with Data Agents and Conversations via skill_ids:

# Data Agent association
class DataAgentModel:
    skill_ids: list[str]  # List of skills available to this Agent

# Conversation association
class ConversationModel:
    skill_ids: list[str]   # List of skills available to this conversation

2.3 Three-Layer Loading Mechanism

Skill loading follows priority order:

---

III. Dynamic Activation Mechanism

3.1 activate_skill Tool

The core is the activate_skill tool, which allows agents to activate skills on demand during conversations:

async def activate_skill(
    skill_name: Annotated[str, Field(description="Skill name to activate")]
) -> str:
    """Activate specified skill, return complete skill instructions."""
    if skill_name not in skill_map:
        return f"Skill '{skill_name}' does not exist. Available: {available_skills}"
    return skill_map[skill_name]

Workflow:

User question → Agent reasoning → Judge need for professional capability → Call activate_skill → Get skill instructions → Continue execution

3.2 Skill Catalog Injection

When an agent loads skills, system prompts include available skill catalog:

Available skills:
- Sales analysis: Analyze sales data, identify trends and anomalies
- Financial report: Generate standard financial statements and analysis
- User profiling: Build user characteristics and behavior analysis

This allows agents to understand when to invoke skills, not just passively respond.

---

IV. Skill Editor: Visual Skill Editing

4.1 Independent Editing Session

System introduced skill_editor conversation type:

class ConversationType(str, Enum):
    chat = "chat"                    # Regular data analysis conversation
    skill_editor = "skill_editor"    # Skill editing conversation

4.2 Dedicated Tool Set

Skill Editor is equipped with exclusive tools:

4.3 AI-Assisted Optimization

Skill Editor's highlight is AI-assisted optimization capability:

User: This is a sales data analysis skill, help me improve it

AI: [Analyze existing skill content] →
    [Identify missing scenarios] →
    [Generate enhancement suggestions] →
    [Update skill content]

Agents can optimize skills through conversation, rather than directly editing JSON or text.

---

V. Practical Scenarios

5.1 Scenario 1: Professional Domain Knowledge Injection

Requirement: Enable AI Agent to have financial industry professional terminology and reporting standards.

Solution:

1. •Create "Financial Report" skill
2. •Write industry-specific report templates and analysis logic
3. •Associate skill with Data Agent

# Financial Report Skill

## Report Standards
- Use standard financial terminology (EBITDA, ROE, ROA, etc.)
- Follow regulatory disclosure formats
- Auto-calculate YoY, QoQ growth rates

## Analysis Framework
1. Profitability analysis
2. Solvency analysis
3. Operating efficiency analysis

5.2 Scenario 2: Multi-Tenant Differentiated Capabilities

Requirement: Different customers have different analysis needs for the same data.

Solution:

• •Create common skills + customer-specific skills for each project
• •Achieve differentiation through skill_ids combination

# Project A's Agent
skill_ids = ["sales_common_analysis", "retail_customerA_exclusive"]

# Project B's Agent
skill_ids = ["sales_common_analysis", "manufacturing_customerB_exclusive"]

5.3 Scenario 3: Skill Version Management

Skill content stored in database supports:

• •Version history (tracked via modified_at)
• •Hot updates (effective immediately after modification, no restart)
• •A/B testing (different user groups use different skill versions)

---

VI. Technical Implementation Highlights

6.1 Protocol Mode Isolation

Skill loading logic separated through three layers:

View layer → Service layer → Repository layer → Database

Easy to extend later (e.g., Git storage, external skill marketplace).

6.2 Backward Compatibility

type field has default value "chat":

type: Mapped[str] = mapped_column(String(50), nullable=False, default="chat")

Existing conversations unaffected.

6.3 Permission Isolation

Skills implement complete isolation via project_id:

• •Users can only see/edit skills in their project
• •Skills invisible to each other between projects

---

VII. Comparison with MCP

AskTable Skill system has similarities with MCP (Model Context Protocol), but different positioning:

Simply put:

• •MCP solves "how to connect external tools"
• •Skill solves "how to organize domain knowledge"

---

VIII. Summary

AskTable Skill system represents a new paradigm for agent capability expansion:

Core philosophy: Capabilities aren't fixed, but assembled on demand.

Three major characteristics:

1. •Project-level management: Skills shared within project, reusable
2. •Dynamic activation: Agents call on demand, controlling context length
3. •AI optimization: Improve skills through conversation, lowering editing barriers

Applicable scenarios:

• •Professional domain knowledge injection
• •Multi-tenant differentiated configuration
• •Skill version management and hot updates
• •Cross-team capability reuse

As the Skill system matures, AskTable is evolving from "general-purpose data analysis tool" to "customizable domain expert platform."

---

Related Reading

• •AskTable AI Agent Working Principles
• •MCP Protocol Detailed