Release Notes - v0.10.0¶

Release Date: 2026-07-05

Overview¶

This release adds the role/ package for defining AI agent roles with declarative specifications, behaviors, policies, and metrics. The GitHub skill has been extracted to a separate omniskill-github repository to keep omniskill lightweight and reduce dependency footprint.

Installation¶

go get github.com/plexusone/omniskill@v0.10.0

Requires Go 1.26+ and MCP Go SDK v1.6.1+.

Highlights¶

New role/ package for AI agent role definitions with behaviors, policies, and metrics
GitHub skill extraction to separate omniskill-github repository for lighter dependency footprint

What's New¶

Role Package¶

The role package provides a complete framework for defining AI agent roles with declarative specifications, behaviors, policies, and metrics:

import (
    "github.com/plexusone/omniskill/role"
)

// Define a role
type MyRole struct {
    role.BaseRole
}

func (r *MyRole) Name() string {
    return "my-role"
}

func (r *MyRole) Description() string {
    return "A custom AI agent role"
}

func (r *MyRole) SystemPrompt() string {
    return "You are a helpful assistant specialized in..."
}

Core Types¶

Role interface - Core interface with Name(), Description(), Spec(), SystemPrompt(), Init(), Close()
RoleSpec - Schema for declarative role introspection and metadata
BaseRole - Helper struct for simple role implementations

Behavior System¶

Define context-aware actions that trigger based on events:

type Behavior struct {
    Name        string
    Description string
    Context     BehaviorContext  // meeting, chat, autonomous, always
    Trigger     BehaviorTrigger  // Event-based activation
    Action      BehaviorAction   // What to execute
}

BehaviorContext enum:

meeting - Active during meetings
chat - Active during chat conversations
autonomous - Active when agent runs autonomously
always - Active in all contexts

BehaviorTrigger - Event-based activation with conditions BehaviorAction - Defines what happens when behavior triggers

Policy System¶

Define governance rules and enforcement modes:

type Policy struct {
    Name        string
    Description string
    Type        PolicyType
    Enforcement PolicyEnforcement
    Rules       map[string]interface{}
}

PolicyType enum:

tool_access - Control which tools can be used
data_access - Control data access permissions
action_limit - Limit action frequency or scope
rate_limit - Rate limiting rules
confirmation_required - Require human confirmation

PolicyEnforcement modes:

strict - Block policy violations
warn - Log warnings but allow
advisory - Informational only

Metrics System¶

Define KPIs and success tracking:

type MetricDefinition struct {
    Name        string
    Description string
    Type        MetricType
    Unit        string
    Target      *MetricTarget
}

MetricType enum:

counter - Incrementing counter
gauge - Point-in-time value
histogram - Distribution of values

MetricTarget - Thresholds for success criteria

Delegation System¶

Configure sub-agent orchestration:

type DelegationConfig struct {
    Enabled bool
    Rules   []DelegationRule
    Budget  *DelegationBudget
}

type DelegationRule struct {
    TaskPattern string   // Pattern to match tasks
    TargetRole  string   // Role to delegate to
    Conditions  []string // Conditions for delegation
}

type DelegationBudget struct {
    MaxDelegations int
    MaxDepth       int
    TimeLimit      time.Duration
}

Optional Interfaces¶

Roles can implement optional interfaces for extended functionality:

SkillRequirer - Declare required and optional skills
BehaviorProvider - Expose role-specific behaviors
MetricsProvider - Expose metrics definitions
DelegationProvider - Expose delegation rules
PolicyProvider - Expose governance policies

// SkillRequirer interface
type SkillRequirer interface {
    RequiredSkills() []string
    OptionalSkills() []string
}

// BehaviorProvider interface
type BehaviorProvider interface {
    Behaviors() []Behavior
}

// MetricsProvider interface
type MetricsProvider interface {
    Metrics() []MetricDefinition
}

// DelegationProvider interface
type DelegationProvider interface {
    DelegationConfig() *DelegationConfig
}

// PolicyProvider interface
type PolicyProvider interface {
    Policies() []Policy
}

GitHub Skill Extraction¶

The GitHub skill has been moved to a separate repository to reduce omniskill's dependency footprint:

New repository: github.com/plexusone/omniskill-github

This removes the thick go-github SDK dependency from the core omniskill library, making it lighter and faster to install.

To use the GitHub skill:

go get github.com/plexusone/omniskill-github@latest

import "github.com/plexusone/omniskill-github/skill"

// Create GitHub skill
githubSkill := skill.NewGitHubSkill(token)

Package Structure¶

github.com/plexusone/omniskill
├── skill/           # Core skill types
├── loader/          # Skill loaders
├── installer/       # Dependency management
├── clawhub/         # ClawHub integration
├── pack/            # Skill pack interface
├── registry/        # Skill registry
├── voicetools/      # Voice call tools
├── role/            # NEW: AI agent role definitions
│   ├── role.go      # Role interface
│   ├── spec.go      # RoleSpec schema
│   ├── base.go      # BaseRole helper
│   ├── behavior.go  # Behavior types and context
│   ├── policy.go    # Policy types and enforcement
│   ├── metric.go    # Metric definitions and targets
│   └── delegation.go # Delegation configuration
└── mcp/             # MCP integration

Use Cases¶

Simple Role with BaseRole¶

package main

import "github.com/plexusone/omniskill/role"

type CustomerServiceRole struct {
    role.BaseRole
}

func (r *CustomerServiceRole) Name() string {
    return "customer-service"
}

func (r *CustomerServiceRole) Description() string {
    return "Customer service agent role"
}

func (r *CustomerServiceRole) SystemPrompt() string {
    return `You are a helpful customer service agent.
Your goal is to assist customers with their questions
and resolve their issues efficiently and courteously.`
}

func NewCustomerServiceRole() *CustomerServiceRole {
    return &CustomerServiceRole{}
}

Role with Behaviors for Meeting Context¶

package main

import (
    "github.com/plexusone/omniskill/role"
)

type MeetingPMRole struct {
    role.BaseRole
}

func (r *MeetingPMRole) Name() string {
    return "meeting-pm"
}

func (r *MeetingPMRole) Description() string {
    return "Project manager for meetings"
}

func (r *MeetingPMRole) SystemPrompt() string {
    return "You are a project manager facilitating meetings."
}

func (r *MeetingPMRole) Behaviors() []role.Behavior {
    return []role.Behavior{
        {
            Name:        "take-notes",
            Description: "Automatically take meeting notes",
            Context:     role.BehaviorContextMeeting,
            Trigger: role.BehaviorTrigger{
                Event: "meeting.started",
            },
            Action: role.BehaviorAction{
                Type: "start_note_taking",
            },
        },
        {
            Name:        "action-item-tracking",
            Description: "Track action items mentioned in meeting",
            Context:     role.BehaviorContextMeeting,
            Trigger: role.BehaviorTrigger{
                Event: "action_item.mentioned",
            },
            Action: role.BehaviorAction{
                Type: "create_task",
            },
        },
    }
}

Role with Policies for Tool Access Control¶

package main

import (
    "github.com/plexusone/omniskill/role"
)

type SecureAgentRole struct {
    role.BaseRole
}

func (r *SecureAgentRole) Name() string {
    return "secure-agent"
}

func (r *SecureAgentRole) Description() string {
    return "Agent with strict security policies"
}

func (r *SecureAgentRole) SystemPrompt() string {
    return "You are a secure agent with restricted permissions."
}

func (r *SecureAgentRole) Policies() []role.Policy {
    return []role.Policy{
        {
            Name:        "tool-allowlist",
            Description: "Only allow specific tools",
            Type:        role.PolicyTypeToolAccess,
            Enforcement: role.PolicyEnforcementStrict,
            Rules: map[string]interface{}{
                "allowed_tools": []string{
                    "read_file",
                    "search",
                },
            },
        },
        {
            Name:        "confirmation-required",
            Description: "Require confirmation for sensitive operations",
            Type:        role.PolicyTypeConfirmationRequired,
            Enforcement: role.PolicyEnforcementStrict,
            Rules: map[string]interface{}{
                "operations": []string{
                    "delete",
                    "update",
                },
            },
        },
    }
}