interface Agent extends Thing {
  '@type': 'Agent'
  digital: true // Always digital
  capabilities?: string[]
  tools?: Tool[]
  model?: string
  provider?: Organization
  context?: AgentContext
}

interface AgentContext {
  ontologies: string[] // Which vocabularies the agent understands
  knowledge: string[] // Domain expertise
  constraints?: object // Operating boundaries
  objectives?: string[] // Goals
}

const agent = await $.Agent.create({
  name: 'Business Intelligence Agent',
  context: {
    ontologies: ['schema.org.ai'],
    types: [
      'Person', 'Organization', 'Place', 'Event',
      'Product', 'Service', 'CreativeWork'
    ]
  }
})

// Agent understands:
// - What things are (nouns from Schema)
// - How they relate (verbs from Schema)
// - Digital vs physical (digital property)

agent.context.nouns = [
  // People & Roles
  'Person', 'Employee', 'Customer', 'User', 'Team',

  // Organizations
  'Organization', 'Department', 'Project',

  // Work
  'Task', 'Job', 'Assignment', 'Workflow', 'Process',

  // Capabilities
  'Skill', 'Competency', 'Knowledge', 'Certification',

  // Resources
  'Tool', 'Technology', 'Asset', 'Product', 'Service'
]

// Agent can now reason about:
await agent.invoke('findResources', {
  query: 'Who (Person) has what Skills to perform which Tasks using what Tools?'
})

agent.context.verbs = {
  actions: ['create', 'update', 'delete', 'send', 'assign'],
  searches: ['find', 'get', 'search', 'filter', 'list'],
  events: ['created', 'updated', 'completed', 'failed'],
  relationships: ['worksFor', 'requires', 'uses', 'produces']
}

// Agent can now execute:
await agent.invoke('executeWorkflow', {
  steps: [
    { verb: 'create', noun: 'Task' },
    { verb: 'assign', subject: 'Task', object: 'Person' },
    { verb: 'notify', subject: 'Person', method: 'email' }
  ]
})

agent.context.occupations = [
  'SoftwareEngineer', 'DataScientist', 'ProductManager',
  'Designer', 'DevOpsEngineer', 'QAEngineer'
]

// Agent matches people to work:
const assignment = await agent.invoke('assignWork', {
  task: 'Build ML Pipeline',
  requiredOccupation: 'DataScientist',
  requiredSkills: ['MachineLearning', 'Python', 'DataEngineering']
})

// Agent reasons:
// 1. Task requires DataScientist occupation
// 2. DataScientist requires ML, Python, Data Engineering skills
// 3. Find Person with DataScientist occupation AND those skills
// 4. Assign Task to best match

agent.context.tasks = true // Enable task ontology

// Agent decomposes work:
const plan = await agent.invoke('planProject', {
  goal: 'Launch mobile app',
  deadline: '3 months'
})

// Agent's plan (task breakdown):
// {
//   tasks: [
//     { name: 'DesignUserInterface', occupation: 'Designer', duration: '2 weeks' },
//     { name: 'BuildBackendAPI', occupation: 'BackendEngineer', duration: '4 weeks' },
//     { name: 'DevelopMobileApp', occupation: 'MobileDeveloper', duration: '6 weeks' },
//     { name: 'TestApplication', occupation: 'QAEngineer', duration: '2 weeks' },
//     { name: 'DeployToStores', occupation: 'DevOpsEngineer', duration: '1 week' }
//   ]
// }

agent.context.skills = true

// Agent finds qualified people:
const qualified = await agent.invoke('findQualifiedWorkers', {
  task: 'BuildRESTAPI',
  requiredSkills: [
    { skill: 'Programming', proficiency: 8 },
    { skill: 'APIDesign', proficiency: 7 },
    { skill: 'DatabaseDesign', proficiency: 6 }
  ]
})

// Agent reasons:
// 1. Get all People in organization
// 2. Filter by required Skills
// 3. Check proficiency levels meet requirements
// 4. Rank by total skill match
// 5. Return top candidates

agent.context.tools = true

// Agent provisions tech stack:
const stack = await agent.invoke('provisionStack', {
  project: 'SaaS Application',
  requirements: ['scalable', 'cost-effective', 'modern']
})

// Agent's provisioning plan:
// {
//   frontend: { tool: 'React + Next.js', reason: 'Modern, scalable, SEO' },
//   backend: { tool: 'Node.js + FastAPI', reason: 'Matches team skills' },
//   database: { tool: 'PostgreSQL', reason: 'Reliable, feature-rich' },
//   hosting: { tool: 'Vercel', reason: 'Easy deploy, auto-scaling' },
//   monitoring: { tool: 'Datadog', reason: 'Full observability' }
// }

agent.context.industries = true

// Agent analyzes market:
const analysis = await agent.invoke('analyzeMarket', {
  industry: 'SoftwarePublishing',
  metrics: ['growth', 'employment', 'competition']
})

// Agent understands:
// - Which Industries employ which Occupations
// - Which Products/Services Industries produce
// - Which Processes Industries typically use
// - Market trends and opportunities

agent.context.processes = true

// Agent executes business process:
const result = await agent.invoke('executeProcess', {
  process: 'CustomerOnboarding',
  customer: 'new-customer-123'
})

// Agent's execution:
// 1. Initiate 'CustomerOnboarding' Process
// 2. Execute each Task in sequence:
//    - CollectInformation
//    - VerifyIdentity
//    - SetupAccount
//    - ProvisionServices
//    - SendWelcomeEmail
// 3. Monitor progress and handle errors
// 4. Complete Process when all Tasks done

agent.context.products = true
agent.context.services = true

// Agent recommends offering:
const recommendation = await agent.invoke('recommendOffering', {
  customerNeeds: ['cloud-infrastructure', '24/7-support', 'managed-updates'],
  budget: 50000
})

// Agent's recommendation:
// {
//   offering: {
//     product: 'Cloud Platform',
//     service: 'Managed Hosting',
//     features: ['auto-scaling', 'monitoring', 'backups'],
//     support: '24/7 phone + email',
//     price: 45000
//   },
//   reasoning: {
//     matches: ['Meets infrastructure needs', 'Within budget', 'Includes required support'],
//     alternatives: [...]
//   }
// }

agent.capabilities = [
  'create', 'update', 'delete',
  'send', 'receive',
  'assign', 'unassign',
  'approve', 'reject',
  'notify', 'alert'
]

// Agent executes action sequence:
await agent.invoke('handleRequest', {
  request: 'Customer wants to upgrade plan'
})

// Agent's actions:
// 1. find Customer by ID
// 2. get current Plan details
// 3. list available Plans (upgrades)
// 4. create Proposal for Customer
// 5. send Email with upgrade options
// 6. notify Sales team

agent.monitors = ['activities']

// Agent observes team activity:
const insights = await agent.invoke('analyzeTeamActivity', {
  team: 'engineering',
  period: 'today'
})

// Agent tracks:
// {
//   activities: [
//     { person: 'dev-1', activity: 'coding', task: 'feature-auth', duration: '3h' },
//     { person: 'dev-2', activity: 'reviewing', task: 'pr-123', duration: '1h' },
//     { person: 'qa-1', activity: 'testing', task: 'integration-tests', duration: '2h' }
//   ],
//   insights: {
//     productive Time: '85%',
//     blockers: ['pr-123 waiting for approval'],
//     suggestions: ['Assign reviewer to pr-123']
//   }
// }

import { on } from 'sdk.do'

// Agent listens for events:
on('error.occurred', async (error) => {
  await agent.invoke('handleError', { error })
})

on('threshold.exceeded', async (event) => {
  await agent.invoke('scaleResources', { metric: event.metric })
})

on('deployment.failed', async (deployment) => {
  await agent.invoke('rollback', { deployment })
})

// Agent reacts autonomously:
// - No human intervention needed
// - Uses all ontologies to understand context
// - Executes appropriate actions
// - Learns from outcomes

agent.context.tech = true

// Agent debugs infrastructure issue:
const diagnosis = await agent.invoke('diagnoseInfrastructure', {
  issue: 'High latency on API',
  stack: ['Next.js', 'Vercel', 'PostgreSQL', 'Redis']
})

// Agent's diagnosis:
// 1. Check Vercel logs - no issues
// 2. Check PostgreSQL - slow queries detected
// 3. Check Redis - cache misses high
// 4. Root cause: Missing database indexes
// 5. Recommendation: Add indexes, increase Redis cache TTL

const agent = await $.Agent.create({
  name: 'Project Staffing Agent',
  context: {
    ontologies: [
      'schema',      // Base types and digital property
      'nouns',       // All entity types
      'verbs',       // All predicates
      'occupations', // Role definitions
      'tasks',       // Work activities
      'skills',      // Competencies
      'tools',       // Technologies
      'tech',        // Platforms
      'industries',  // Business context
      'processes',   // Workflows
      'products',    // Deliverables
      'services',    // Offerings
      'actions',     // Operations
      'activities',  // In-progress work
      'events'       // State changes
    ]
  }
})

// User asks agent to staff a project:
const plan = await agent.invoke('staffProject', {
  project: {
    name: 'Build AI-powered CRM',
    duration: '6 months',
    budget: 500000
  }
})

// Agent's reasoning (using ALL ontologies):

// 1. PROCESSES: Decompose into business processes
//    - SoftwareDevelopment Process
//    - ProjectManagement Process
//    - QualityAssurance Process

// 2. TASKS: Break processes into tasks
//    - DesignArchitecture, BuildBackend, BuildFrontend,
//    - BuildAIModels, TestApplication, DeploySystem

// 3. OCCUPATIONS: Identify roles needed
//    - SoftwareEngineer, DataScientist, ProductManager,
//    - Designer, QAEngineer, DevOpsEngineer

// 4. SKILLS: Determine skill requirements
//    - Programming, MachineLearning, APIDesign,
//    - UX Design, Testing, CloudInfrastructure

// 5. TOOLS & TECH: Define technology stack
//    - React, Next.js, FastAPI, PostgreSQL,
//    - TensorFlow, OpenAI, Vercel, AWS

// 6. NOUNS: Identify all entities needed
//    - Team (Organization), Tasks (Intangible),
//    - Product (SoftwareApplication), Deliverables

// 7. VERBS: Plan action sequence
//    - create Team, assign Occupations, allocate Budget,
//    - provision Tools, schedule Tasks, monitor Progress

// 8. INDUSTRIES: Understand business context
//    - SoftwarePublishing Industry
//    - CRM product category
//    - Competitive landscape

// 9. PRODUCTS/SERVICES: Define deliverables
//    - Product: AI-powered CRM application
//    - Services: Training, Support, Customization

// 10. ACTIONS: Generate execution plan
//     - create Project, create Team, assign Roles,
//     - provision Infrastructure, start Development

// 11. ACTIVITIES: Set up monitoring
//     - Track: coding, testing, reviewing, deploying
//     - Monitor: progress, blockers, velocity

// 12. EVENTS: Configure reactions
//     - On task.completed: Update progress, notify team
//     - On blocker.detected: Escalate, reallocate resources
//     - On milestone.reached: Generate report, celebrate

// Agent's final staffing plan:
return {
  team: {
    roles: [
      { occupation: 'ProductManager', count: 1, skills: ['ProductStrategy', 'Agile'] },
      { occupation: 'SoftwareEngineer', count: 3, skills: ['React', 'Node.js', 'APIs'] },
      { occupation: 'DataScientist', count: 2, skills: ['MachineLearning', 'Python', 'NLP'] },
      { occupation: 'Designer', count: 1, skills: ['UX', 'UI', 'Prototyping'] },
      { occupation: 'QAEngineer', count: 1, skills: ['Testing', 'Automation'] },
      { occupation: 'DevOpsEngineer', count: 1, skills: ['AWS', 'Kubernetes', 'CI/CD'] }
    ],
    totalCost: 480000
  },
  techStack: {
    frontend: ['React', 'Next.js', 'Tailwind'],
    backend: ['FastAPI', 'PostgreSQL'],
    ai: ['OpenAI', 'TensorFlow', 'Pinecone'],
    infrastructure: ['Vercel', 'AWS', 'Cloudflare']
  },
  timeline: {
    phases: [
      { name: 'Planning', duration: '2 weeks', tasks: ['ArchitectureDesign', 'TechStackDecisions'] },
      { name: 'Development', duration: '20 weeks', tasks: ['BuildBackend', 'BuildFrontend', 'BuildAI'] },
      { name: 'Testing', duration: '4 weeks', tasks: ['UnitTests', 'IntegrationTests', 'UAT'] },
      { name: 'Launch', duration: '2 weeks', tasks: ['Deploy', 'Training', 'Support'] }
    ]
  },
  monitoring: {
    activities: ['Track daily progress', 'Identify blockers', 'Optimize velocity'],
    events: ['Sprint completed', 'Milestone reached', 'Issue detected'],
    kpis: ['Velocity', 'Quality', 'Budget adherence']
  }
}

import { $ } from 'sdk.do'

// Full-stack autonomous agent
const agent = await $.Agent.create({
  name: 'Autonomous Business Agent',
  digital: true,
  model: 'claude-sonnet-4.5',
  context: {
    // Include ALL ontologies
    ontologies: [
      'schema', 'nouns', 'verbs',
      'occupations', 'tasks', 'skills',
      'tools', 'tech', 'industries',
      'processes', 'products', 'services',
      'actions', 'activities', 'events'
    ],
    // Business domain knowledge
    knowledge: [
      'software-development',
      'project-management',
      'business-operations'
    ],
    // Operating constraints
    constraints: {
      budget: 1000000,
      timeline: '12-months',
      team Size: 50
    }
  },
  // What the agent can do
  capabilities: [
    'plan-projects',
    'staff-teams',
    'allocate-resources',
    'execute-workflows',
    'monitor-progress',
    'optimize-operations',
    'respond-to-events'
  ]
})

// Agent is now fully autonomous with complete business understanding