Context

context <Name> {
  memory: <scope>
  language: <string>
  depth: <level>
  max_tokens: <integer>
  temperature: <float>
  cite_sources: <boolean>
}

context LongTermContext {
  memory: persistent    // Memory persists across sessions
}

context OneOffTask {
  memory: none         // No memory retention
}

context ChatSession {
  memory: session      // Memory lasts for the session
}

context TemporaryWork {
  memory: ephemeral    // Short-lived memory
}

context EnglishContext {
  language: "en"
}

context SpanishReview {
  language: "es"
  depth: exhaustive
}

context QuickScan {
  depth: shallow       // Fast, surface-level
}

context StandardReview {
  depth: standard      // Balanced depth
}

context DetailedAnalysis {
  depth: deep          // Thorough investigation
}

context ComprehensiveAudit {
  depth: exhaustive    // Maximum detail
}

context BriefResponses {
  max_tokens: 500      // Short responses
}

context StandardContext {
  max_tokens: 4096     // Typical context window
}

context ExtendedReport {
  max_tokens: 16000    // Long-form content
}

context FactualAnalysis {
  temperature: 0.0     // Deterministic, factual
}

context LegalReview {
  temperature: 0.3     // Mostly deterministic, slight variation
}

context BalancedGeneration {
  temperature: 0.7     // Balanced creativity
}

context CreativeWriting {
  temperature: 1.2     // High creativity
}

context ResearchMode {
  cite_sources: true
  depth: deep
}

context CasualChat {
  cite_sources: false
}

context LegalReview {
  memory: session
  language: "en"
  depth: exhaustive
  max_tokens: 4096
  temperature: 0.3
  cite_sources: true
}

context QuickSummary {
  memory: none
  depth: shallow
  max_tokens: 500
  temperature: 0.5
}

context AcademicResearch {
  memory: persistent
  language: "en"
  depth: deep
  max_tokens: 8000
  temperature: 0.4
  cite_sources: true
}

context CreativeMode {
  memory: session
  depth: standard
  max_tokens: 4096
  temperature: 1.0
  cite_sources: false
}

context Production {
  memory: session
  language: "en"
  depth: standard
  max_tokens: 4096
  temperature: 0.5
}

context AnalysisContext {
  depth: deep
  temperature: 0.3
}

flow AnalyzeDocument(doc: Document) -> Report { ... }

run AnalyzeDocument(myDoc)
  as Analyst
  within AnalysisContext    // Execute in this context

// High-stakes: legal, medical, financial
context CriticalAnalysis {
  depth: exhaustive
  temperature: 0.2
  cite_sources: true
}

// Low-stakes: brainstorming, drafts
context ExploratoryMode {
  depth: standard
  temperature: 0.8
  cite_sources: false
}

// Persistent: for user-specific knowledge
context UserProfile {
  memory: persistent
  // Remember user preferences, history
}

// Session: for conversation context
context Conversation {
  memory: session
  // Remember within chat, forget after
}

// None: for stateless operations
context StatelessAPI {
  memory: none
  // No state, pure function
}

// Need reproducibility? Use low temperature
context DataAnalysis {
  temperature: 0.1  // Nearly deterministic
  depth: deep
}

// Need variety? Use higher temperature
context ContentIdeas {
  temperature: 1.0  // More creative variation
}

context APIEndpoint {
  max_tokens: 1000   // Keep responses concise for APIs
  temperature: 0.5
}

context ReportGeneration {
  max_tokens: 8000   // Allow detailed reports
  depth: deep
}

persona LegalExpert {
  domain: ["contract law"]
  tone: precise
}

context LegalReview {
  depth: exhaustive
  temperature: 0.3
  cite_sources: true
}

run AnalyzeContract(doc)
  as LegalExpert        // Who
  within LegalReview    // How

context Development {
  depth: shallow
  max_tokens: 1000
  temperature: 0.7
}

context Production {
  depth: deep
  max_tokens: 4096
  temperature: 0.5
  cite_sources: true
}

// Switch contexts based on environment
run MyFlow(data)
  as MyPersona
  within Production  // or Development

context EnglishContext {
  language: "en"
  depth: standard
}

context SpanishContext {
  language: "es"
  depth: standard
}

context FrenchContext {
  language: "fr"
  depth: standard
}

context QuickPass {
  depth: shallow
  max_tokens: 1000
}

context StandardPass {
  depth: standard
  max_tokens: 4096
}

context DetailedPass {
  depth: deep
  max_tokens: 8000
}

context ComprehensivePass {
  depth: exhaustive
  max_tokens: 16000
  cite_sources: true
}

// Run multiple passes with increasing depth
run FirstPass(doc) within QuickPass
run SecondPass(doc) within DetailedPass

context Invalid {
  memory: unlimited           // ❌ Error: unknown memory scope
  depth: superficial          // ❌ Error: unknown depth level
  temperature: 3.0            // ❌ Error: out of range
  max_tokens: -100            // ❌ Error: must be positive
}

run MyFlow(data) within UnknownContext  // ❌ Error: undefined context

// Fast but shallow
context QuickMode {
  depth: shallow
  max_tokens: 500
}

// Slow but thorough
context ThoroughMode {
  depth: exhaustive
  max_tokens: 16000
}

// Better personalization, but stores data
context Personalized {
  memory: persistent
}

// Privacy-first, no retention
context Private {
  memory: none
}