Agent

import { Noun } from 'digital-objects'

export const Agent = Noun('Agent', {
  name: 'string!',
  slug: 'string##',
  description: 'string',
  avatar: 'string',
  organization: '-> Organization',
  owner: '-> Contact',
  model: 'string',
  systemPrompt: 'string',
  instructions: 'string',
  persona: 'string',
  type: 'Assistant | Autonomous | Workflow | Specialist | Router',
  status: 'Draft | Active | Deployed | Paused | Stopped | Retired | Archived',
  visibility: 'Private | Team | Organization | Public',
  temperature: 'number',
  maxTokens: 'number',
  tools: 'json',
  functions: 'json',
  knowledgeBases: 'json',
  memory: 'None | Session | Persistent',
  memoryWindow: 'number',
  totalTokens: 'number',
  totalCost: 'number',
  averageLatency: 'number',
  successRate: 'number',
  rating: 'number',
  ratingCount: 'number',
  version: 'number',
  publishedAt: 'datetime',
  tags: 'string',
  do: 'Done',
  ask: 'Asked',
  decide: 'Decided',
  approve: 'Approved',
  notify: 'Notified',
  delegate: 'Delegated',
  escalate: 'Escalated',
  learn: 'Learned',
  reflect: 'Reflected',
  invoke: 'Invoked',
  deploy: 'Deployed',
  pause: 'Paused',
  stop: 'Stopped',
  retire: 'Retired',
})

import { Agent } from '@headlessly/platform'

// BEFORE hook -- validate before deployment
Agent.deploying(agent => {
  if (!agent.systemPrompt) {
    throw new Error('System prompt required before deployment')
  }
  if (!agent.tools || agent.tools.length === 0) {
    throw new Error('At least one tool must be configured')
  }
})

// Execute -- deploy the agent
await Agent.deploy('agent_mR4nVkTw')

// AFTER hook -- notify and track
Agent.deployed((agent, $) => {
  $.Event.create({
    type: 'agent.deployed',
    data: {
      agent: agent.$id,
      model: agent.model,
      type: agent.type,
      version: agent.version,
    },
  })
  $.Activity.create({
    subject: `Agent deployed: ${agent.name}`,
    type: 'Task',
    contact: agent.owner,
    status: 'Completed',
  })
})

Draft --> Active --> Deployed --> Paused --> Deployed
                        |            |
                        v            v
                     Stopped     Stopped
                        |            |
                        v            v
                     Retired --> Archived

import { Agent } from '@headlessly/platform'

// When an agent escalates, create a ticket
Agent.escalated((agent, $) => {
  $.Ticket.create({
    subject: `Escalation from ${agent.name}`,
    description: 'Agent could not resolve this issue autonomously',
    priority: 'High',
    status: 'Open',
  })
})

// When an agent learns from feedback, log the improvement
Agent.learned((agent, $) => {
  $.Event.create({
    type: 'agent.learned',
    data: {
      agent: agent.$id,
      successRate: agent.successRate,
      rating: agent.rating,
    },
  })
})

// Delegation pattern -- router agent delegates to specialists
Agent.delegated((router, $) => {
  $.Event.create({
    type: 'agent.delegated',
    data: {
      from: router.$id,
      reason: 'Routing to domain specialist',
    },
  })
})

import { Agent } from '@headlessly/platform'

// Find all deployed agents
const deployed = await Agent.find({ status: 'Deployed' })

// Get a specific agent
const agent = await Agent.get('agent_mR4nVkTw')

// Create a support agent
const supportAgent = await Agent.create({
  name: 'Support Agent',
  slug: 'support-agent',
  type: 'Specialist',
  model: 'claude-opus-4-6',
  systemPrompt: 'You are a customer support agent for headless.ly. Help users with setup, billing, and technical questions.',
  tools: ['search', 'fetch', 'do'],
  memory: 'Session',
  memoryWindow: 20,
  visibility: 'Organization',
})
await Agent.deploy(supportAgent.$id)

// Ask the agent a question
await Agent.ask('agent_mR4nVkTw', {
  message: 'How do I set up Stripe integration?',
})

// Check agent health metrics
const agents = await Agent.find({ status: 'Deployed' })
for (const a of agents) {
  console.log(`${a.name}: ${a.successRate}% success, ${a.averageLatency}ms avg latency, $${a.totalCost} total cost`)
}

{
  "type": "Agent",
  "filter": { "status": "Deployed", "type": "Specialist" },
  "sort": { "successRate": "desc" },
  "limit": 10
}

{ "type": "Agent", "id": "agent_mR4nVkTw" }

const agents = await $.Agent.find({ status: 'Deployed' })
await $.Agent.invoke('agent_mR4nVkTw')
await $.Agent.pause('agent_mR4nVkTw')

# List deployed agents
curl https://automate.headless.ly/~acme/agents?status=Deployed

# Get a specific agent
curl https://automate.headless.ly/~acme/agents/agent_mR4nVkTw

# Create an agent
curl -X POST https://automate.headless.ly/~acme/agents \
  -H 'Content-Type: application/json' \
  -d '{"name": "Support Agent", "type": "Specialist", "model": "claude-opus-4-6"}'

# Deploy an agent
curl -X POST https://automate.headless.ly/~acme/agents/agent_mR4nVkTw/deploy

# Invoke an agent
curl -X POST https://automate.headless.ly/~acme/agents/agent_mR4nVkTw/invoke

# Pause an agent
curl -X POST https://automate.headless.ly/~acme/agents/agent_mR4nVkTw/pause

# Retire an agent
curl -X POST https://automate.headless.ly/~acme/agents/agent_mR4nVkTw/retire