Agentlang Syntax Reference (v1.0)

module <ModuleName>
 
import "<path>" @as <alias>

module acme.erp
import "emailClient.js" @as email

<ModuleDecl> |
<RecordDecl> |
<EntityDecl> |
<RelationshipDecl> |
<EventDecl> |
<WorkflowDecl> |
<DecisionDecl> |
<AgentDecl> |
<ScenarioDecl> |
<DirectiveDecl> |
<GlossaryDecl> |
<FlowDecl>

record <Name> {
   <FieldList>
}

record Address {
   street String,
   city String,
   pincode Int
}

entity <Name> [extends <Base>] {
   <FieldList>
}

entity Employee {
   email Email @id,
   name String,
   salary Decimal
}

entity Invoice {
   id UUID @id @default(uuid()),
   createdAt DateTime @default(now()),
   amount Decimal @check(isPositive),
   status @enum("draft", "sent", "paid"),
   customerId UUID @oneof(Customer.id)
}

relationship <Name> {
   <EntityA> <Verb> <EntityB>
}

relationship EmployeeReportsTo {
   Employee reports_to Manager
}

event <Name> {
   <FieldList>
}

event giveIncrementToEmployee {
   employeeEmail Email,
   increment Decimal
}

workflow <Name> {
   <WorkflowBody>
}

{<Entity> {<field> <value>, ...}}

{Employee {email "jane@acme.com", salary 50000}}

{Employee {email? "john@acme.com"}}

{Employee? {}}

{Student {age?> 10}}

=, <>, !=, <, <=, >, >=, in, like, between

{Student {age?between [10, 15]}}
{Student {name?like "Mat%"}}

delete {E {id? 1}}
{E {id 1, v 10}, @upsert}

if (<condition>) { ... } else { ... }
for (<x> in <collection>) { ... }

workflow @before create:<Entity> { ... }
workflow @after update:<Entity> { ... }

workflow @after create:Employee {
   console.log("Employee created: " + this.email)
}

import "emailClient.js" @as email
 
workflow sendMail {
    email.sendMail(sendMail.to, sendMail.body)
}

decision <Name> {
   case (<condition>) { <Result> }
   case (<condition>) { <Result> }
}

decision classifyOrder {
  case (carType == "EV" and segment == "economy") { EconomyEV }
  case (carType == "SUV" and segment == "luxury") { LuxurySUV }
}

agent <Name> {
   role "<string>",
   instruction "<template-string>",
   tools [<WorkflowName>, ...],
   directives [<DirectiveList>],
   scenarios [<ScenarioList>],
   glossary [<GlossaryList>],
   type "chat" | "planner"
}

agent employeeIncrement {
   role "You decide salary increments",
   instruction "Based on total sales {{totalSales}} of {{employeeEmail}}, give the right increment",
   tools [giveIncrementToEmployee],
   directives [
       {"if": "sales > 5000", "then": "increment .5"},
       {"if": "sales between 2000 and 5000", "then": "increment .2"}
   ],
   scenarios [
       {"user": "sales 5600 for jake@acme.com", "ai": "[{acme.core/giveIncrementToEmployee {email \"jake@acme.com\", increment .5}}]"}
   ]
}

glossary <AgentName>.<id> {
   "name": "<term>",
   "meaning": "<definition>",
   "synonyms": "<comma-separated synonyms>"
}

directive <AgentName>.<id> {"if": "<condition>", "then": "<action>"}
scenario <AgentName>.<id> {"user": "<input>", "ai": "<response>"}

flow <Name> {
   <Source> --> <Target>
   ...
}
 
@public agent <FlowName> {
   instruction "<role description>"
}

flow incrementProcess {
   findEmployeeSales --> employeeIncrement
}
  
@public agent incrementProcess {
   role "You manage employee increments"
}

// Single-line comment
/* Multi-line comment */

module, import, record, entity, relationship, event, workflow, agent,
decision, flow, delete, if, else, for, in, let, case, role, instruction,
tools, directives, scenarios, glossary, @before, @after, @on, @public,
extends, @id, @indexed, @optional, @default, @unique, @readonly,
@check, @enum, @oneof

module acme.erp
  
entity Employee {
   email Email @id,
   name String,
   salary Decimal
}
  
entity EmployeeSales {
   id UUID @default(uuid()),
   employee Email,
   totalSales Decimal
}
  
event giveIncrementToEmployee {
   employeeEmail Email,
   increment Decimal
}
  
workflow giveIncrementToEmployee {
    {Employee {email? giveIncrementToEmployee.employeeEmail,
               salary salary + salary * giveIncrementToEmployee.increment}}
}
  
agent employeeIncrement {
    role "You decide increments for employees",
    instruction "Based on {{totalSales}} for {{employeeEmail}}, decide increment",
    tools [giveIncrementToEmployee],
    directives [{"if": "sales > 5000", "then": "increment .5"}]
}
  
flow incrementProcess {
    findEmployeeSales --> employeeIncrement
}
  
@public agent incrementProcess {
   role "Manage the salary increment process"
}

Module          = "module" Identifier { TopLevelDecl } ;
TopLevelDecl    = RecordDecl | EntityDecl | RelationshipDecl |
                  EventDecl | WorkflowDecl | AgentDecl | DecisionDecl | FlowDecl ;

RecordDecl      = "record" Identifier "{" FieldList "}" ;
EntityDecl      = "entity" Identifier [ "extends" Identifier ] "{" FieldList "}" ;
FieldList       = { Identifier Type [ AttributeList ] "," } ;
AttributeList   = { "@" Identifier [ "(" Expression ")" ] } ;

EventDecl       = "event" Identifier "{" FieldList "}" ;

WorkflowDecl    = "workflow" [ WorkflowQualifier ] Identifier "{" WorkflowBody "}" ;
WorkflowQualifier = "@" Identifier [ ":" Identifier ] ;
WorkflowBody    = { WorkflowStmt } ;
WorkflowStmt    = Pattern | DeletePattern | IfStmt | ForStmt | JsCall ;

Pattern         = "{" Identifier "{" FieldAssignments "}" [ "," "@" "upsert" ] "}" ;
DeletePattern   = "delete" Pattern ;

DecisionDecl    = "decision" Identifier "{" { CaseClause } "}" ;
CaseClause      = "case" "(" Expression ")" "{" Identifier "}" ;

AgentDecl       = "agent" Identifier "{" AgentBody "}" ;
AgentBody       = { AgentField } ;
AgentField      = "role" StringLiteral |
                  "instruction" StringLiteral |
                  "tools" "[" Identifier { "," Identifier } "]" |
                  "directives" "[" JsonList "]" |
                  "scenarios" "[" JsonList "]" |
                  "glossary" "[" JsonList "]" |
                  "type" StringLiteral ;

FlowDecl        = "flow" Identifier "{" { FlowEdge } "}" ;
FlowEdge        = Identifier "-->" Identifier ;