diff --git a/src/LLMExecutor.ts b/src/LLMExecutor.ts
new file mode 100644
index 0000000..76f0c8e
--- /dev/null
+++ b/src/LLMExecutor.ts
@@ -0,0 +1,163 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ */
+
+import { LLMProviderAdapter } from './LLMProviderAdapter';
+import { OpenAIAdapter } from './providers/OpenAIAdapter';
+
+export type LLMProvider = 'openai' | 'anthropic' | 'ollama';
+
+export interface LLMConfig {
+    provider: LLMProvider;
+    model: string;
+    apiKey?: string;
+    baseUrl?: string;
+    temperature?: number;
+}
+
+export interface ExecutorInput {
+    contractText: string;
+    state: Record<string, unknown>;
+    request: Record<string, unknown>;
+    modelDefinitions?: string;
+}
+
+export interface InitExecutorInput {
+    contractText: string;
+    request: Record<string, unknown>;
+    modelDefinitions?: string;
+}
+
+export interface ExecutorOutput {
+    response: Record<string, unknown>;
+    state: Record<string, unknown>;
+    emit: Record<string, unknown>[];
+}
+
+type InitOutput = {
+    state: Record<string, unknown>;
+};
+
+export class LLMExecutorError extends Error {
+    readonly code: 'INVALID_JSON' | 'INVALID_SHAPE' | 'PROVIDER_ERROR';
+
+    constructor(code: LLMExecutorError['code'], message: string) {
+        super(message);
+        this.name = 'LLMExecutorError';
+        this.code = code;
+    }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export class LLMExecutor {
+    private readonly adapterOverride?: LLMProviderAdapter;
+
+    constructor(adapter?: LLMProviderAdapter) {
+        this.adapterOverride = adapter;
+    }
+
+    private getAdapter(config: LLMConfig): LLMProviderAdapter {
+        if (this.adapterOverride) {
+            return this.adapterOverride;
+        }
+        if (config.provider === 'openai') {
+            return new OpenAIAdapter();
+        }
+        throw new LLMExecutorError('PROVIDER_ERROR', `Unsupported provider: ${config.provider}`);
+    }
+
+    private buildTriggerPrompt(input: ExecutorInput): string {
+        return [
+            'You are executing contract logic.',
+            'Return only valid JSON with this exact shape:',
+            '{"response": {...}, "state": {...}, "emit": [{...}]}',
+            'No markdown. No prose.',
+            `Contract:\n${input.contractText}`,
+            input.modelDefinitions ? `Model Definitions:\n${input.modelDefinitions}` : '',
+            `Current State JSON:\n${JSON.stringify(input.state)}`,
+            `Request JSON:\n${JSON.stringify(input.request)}`
+        ].filter(Boolean).join('\n\n');
+    }
+
+    private buildInitPrompt(input: InitExecutorInput): string {
+        return [
+            'You are initializing contract state.',
+            'Return only valid JSON with this exact shape:',
+            '{"state": {...}}',
+            'No markdown. No prose.',
+            `Contract:\n${input.contractText}`,
+            input.modelDefinitions ? `Model Definitions:\n${input.modelDefinitions}` : '',
+            `Init Request JSON:\n${JSON.stringify(input.request)}`
+        ].filter(Boolean).join('\n\n');
+    }
+
+    parseModelJson(text: string): unknown {
+        try {
+            return JSON.parse(text);
+        } catch (err) {
+            const message = err instanceof Error ? err.message : 'Unknown JSON parse error';
+            throw new LLMExecutorError('INVALID_JSON', `Model output is not valid JSON: ${message}`);
+        }
+    }
+
+    assertTriggerShape(value: unknown): ExecutorOutput {
+        if (!isRecord(value)) {
+            throw new LLMExecutorError('INVALID_SHAPE', 'Trigger output must be an object');
+        }
+        if (!isRecord(value.response)) {
+            throw new LLMExecutorError('INVALID_SHAPE', 'Trigger output.response must be an object');
+        }
+        if (!isRecord(value.state)) {
+            throw new LLMExecutorError('INVALID_SHAPE', 'Trigger output.state must be an object');
+        }
+        if (!Array.isArray(value.emit) || !value.emit.every((x) => isRecord(x))) {
+            throw new LLMExecutorError('INVALID_SHAPE', 'Trigger output.emit must be an array of objects');
+        }
+
+        return {
+            response: value.response,
+            state: value.state,
+            emit: value.emit
+        };
+    }
+
+    assertInitShape(value: unknown): InitOutput {
+        if (!isRecord(value)) {
+            throw new LLMExecutorError('INVALID_SHAPE', 'Init output must be an object');
+        }
+        if (!isRecord(value.state)) {
+            throw new LLMExecutorError('INVALID_SHAPE', 'Init output.state must be an object');
+        }
+
+        return {
+            state: value.state
+        };
+    }
+
+    async trigger(input?: ExecutorInput, config?: LLMConfig): Promise<ExecutorOutput> {
+        if (!input || !config) {
+            throw new LLMExecutorError('PROVIDER_ERROR', 'Missing input/config for trigger');
+        }
+
+        const adapter = this.getAdapter(config);
+        const prompt = this.buildTriggerPrompt(input);
+        const raw = await adapter.completeJson(prompt, config);
+        const parsed = this.parseModelJson(raw);
+        return this.assertTriggerShape(parsed);
+    }
+
+    async init(input?: InitExecutorInput, config?: LLMConfig): Promise<InitOutput> {
+        if (!input || !config) {
+            throw new LLMExecutorError('PROVIDER_ERROR', 'Missing input/config for init');
+        }
+
+        const adapter = this.getAdapter(config);
+        const prompt = this.buildInitPrompt(input);
+        const raw = await adapter.completeJson(prompt, config);
+        const parsed = this.parseModelJson(raw);
+        return this.assertInitShape(parsed);
+    }
+}
\ No newline at end of file
diff --git a/src/LLMProviderAdapter.ts b/src/LLMProviderAdapter.ts
new file mode 100644
index 0000000..53c0d49
--- /dev/null
+++ b/src/LLMProviderAdapter.ts
@@ -0,0 +1,9 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ */
+
+import { LLMConfig } from './LLMExecutor';
+
+export interface LLMProviderAdapter {
+    completeJson(prompt: string, config: LLMConfig): Promise<string>;
+}
\ No newline at end of file
diff --git a/src/TemplateArchiveProcessor.ts b/src/TemplateArchiveProcessor.ts
index 3fd8f56..4d4b9ec 100644
--- a/src/TemplateArchiveProcessor.ts
+++ b/src/TemplateArchiveProcessor.ts
@@ -15,6 +15,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { Template } from '@accordproject/cicero-core';
+import { LLMExecutor, LLMConfig } from './LLMExecutor';
 import { TemplateMarkInterpreter } from './TemplateMarkInterpreter';
 import { TemplateMarkTransformer } from '@accordproject/markdown-template';
 import { transform } from '@accordproject/markdown-transform';
@@ -32,11 +33,11 @@ export type TriggerResponse = {
     result: Response;
     state: State;
     events: Event[];
-}
+};
 
 export type InitResponse = {
     state: State;
-}
+};
 
 /**
  * A template archive processor: can draft content using the
@@ -62,123 +63,142 @@ export class TemplateArchiveProcessor {
      * @returns {Promise} the drafted content
      */
     async draft(data: any, format: string, options: any, currentTime?: string): Promise<any> {
-        // Setup
         const metadata = this.template.getMetadata();
         const templateKind = metadata.getTemplateType() !== 0 ? 'clause' : 'contract';
 
-        // Get the data
         const modelManager = this.template.getModelManager();
         const engine = new TemplateMarkInterpreter(modelManager, {});
         const templateMarkTransformer = new TemplateMarkTransformer();
         const templateMarkDom = templateMarkTransformer.fromMarkdownTemplate(
-            { content: this.template.getTemplate() }, modelManager, templateKind, {options});
+            { content: this.template.getTemplate() }, modelManager, templateKind, { options }
+        );
         const now = currentTime ? currentTime : new Date().toISOString();
-        // console.log(JSON.stringify(templateMarkDom, null, 2));
         const ciceroMark = await engine.generate(templateMarkDom, data, { now });
-        // console.log(JSON.stringify(ciceroMark));
-        const result = transform(ciceroMark.toJSON(), 'ciceromark', ['ciceromark_unquoted', format], null, options);
-        // console.log(result);
-        return result;
+        return transform(ciceroMark.toJSON(), 'ciceromark', ['ciceromark_unquoted', format], null, options);
+    }
 
+    private getContractTextForLLM(): string {
+        const scriptManager = this.template.getScriptManager();
+        const logicScript = scriptManager.getScript('logic/logic.ts');
+        return logicScript ? logicScript.getContents() : '';
     }
 
-    /**
-     * Trigger the logic of a template
-     * @param {object} request - the request to send to the template logic
-     * @param {object} state - the current state of the template
-     * @param {[string]} currentTime - the current time, defaults to now
-     * @param {[number]} utcOffset - the UTC offer, defaults to zero
-     * @returns {Promise} the response and any events
-     */
-    async trigger(data: any, request: any, state?: any, currentTime?: string, utcOffset?: number): Promise<TriggerResponse> {
+    private getModelDefinitionsForLLM(): string {
+    const modelManager = this.template.getModelManager();
+    return modelManager.getModels().map((m: { getDefinitions: () => string }) => m.getDefinitions()).join('\n');
+}
+
+    async trigger(
+        data: any,
+        request: any,
+        state?: any,
+        currentTime?: string,
+        utcOffset?: number,
+        llmConfig?: LLMConfig
+    ): Promise<TriggerResponse> {
         const logicManager = this.template.getLogicManager();
-        if(logicManager.getLanguage() === 'typescript') {
-            const compiledCode:Record<string, TwoSlashReturn> = {};
-            const tsFiles:Array<Script> = logicManager.getScriptManager().getScriptsForTarget('typescript');
-            for(let n=0; n < tsFiles.length; n++) {
+        if (logicManager.getLanguage() === 'typescript') {
+            const compiledCode: Record<string, TwoSlashReturn> = {};
+            const tsFiles: Array<Script> = logicManager.getScriptManager().getScriptsForTarget('typescript');
+            for (let n = 0; n < tsFiles.length; n++) {
                 const tsFile = tsFiles[n];
-                // console.log(`Compiling ${tsFile.getIdentifier()}`);
-
-                const compiler = new TypeScriptToJavaScriptCompiler(this.template.getModelManager(),
-                    this.template.getTemplateModel().getFullyQualifiedName());
+                const compiler = new TypeScriptToJavaScriptCompiler(
+                    this.template.getModelManager(),
+                    this.template.getTemplateModel().getFullyQualifiedName()
+                );
 
                 await compiler.initialize();
 
-                // add the runtime type definitions to all ts files??
                 const code = `${Buffer.from(SMART_LEGAL_CONTRACT_BASE64, 'base64').toString()}
-                ${tsFile.getContents()}`
+                ${tsFile.getContents()}`;
 
-                const result = compiler.compile(code);
-                compiledCode[tsFile.getIdentifier()] = result;
+                compiledCode[tsFile.getIdentifier()] = compiler.compile(code);
             }
-            // console.log(compiledCode['logic/logic.ts'].code);
+
             const evaluator = new JavaScriptEvaluator();
-            const evalResponse = await evaluator.evalDangerously( {
+            const evalResponse = await evaluator.evalDangerously({
                 templateLogic: true,
                 verbose: false,
                 functionName: 'trigger',
-                code: compiledCode['logic/logic.ts'].code, // TODO DCS - how to find the code to run?
-                argumentNames: ['data', 'request', 'state'],
+                code: compiledCode['logic/logic.ts'].code,
+                argumentNames: ['data', 'request', 'state', 'currentTime', 'utcOffset'],
                 arguments: [data, request, state, currentTime, utcOffset]
             });
-            if(evalResponse.result) {
+
+            if (evalResponse.result) {
                 return evalResponse.result;
             }
-            else {
-                throw new Error('Trigger failed with message: ' + evalResponse.message);
-            }
-        }
-        else {
-            throw new Error('Only TypeScript is supported at this time');
+            throw new Error(`Trigger failed with message: ${evalResponse.message}`);
+        } else if (llmConfig) {
+            const executor = new LLMExecutor();
+            const output = await executor.trigger(
+                {
+                    contractText: this.getContractTextForLLM(),
+                    state: (state ?? {}) as Record<string, unknown>,
+                    request: (request ?? {}) as Record<string, unknown>,
+                    modelDefinitions: this.getModelDefinitionsForLLM()
+                },
+                llmConfig
+            );
+            return {
+                result: output.response,
+                state: output.state,
+                events: output.emit
+            };
         }
+
+        throw new Error('Only TypeScript is supported at this time');
     }
 
-    /**
-     * Init the logic of a template
-     * @param {[string]} currentTime - the current time, defaults to now
-     * @param {[number]} utcOffset - the UTC offer, defaults to zero
-     * @returns {Promise} the response and any events
-     */
-    async init(data: any, currentTime?: string, utcOffset?: number): Promise<InitResponse> {
+    async init(data: any, currentTime?: string, utcOffset?: number, llmConfig?: LLMConfig): Promise<InitResponse> {
         const logicManager = this.template.getLogicManager();
-        if(logicManager.getLanguage() === 'typescript') {
-            const compiledCode:Record<string, TwoSlashReturn> = {};
-            const tsFiles:Array<Script> = logicManager.getScriptManager().getScriptsForTarget('typescript');
-            for(let n=0; n < tsFiles.length; n++) {
+        if (logicManager.getLanguage() === 'typescript') {
+            const compiledCode: Record<string, TwoSlashReturn> = {};
+            const tsFiles: Array<Script> = logicManager.getScriptManager().getScriptsForTarget('typescript');
+            for (let n = 0; n < tsFiles.length; n++) {
                 const tsFile = tsFiles[n];
-                // console.log(`Compiling ${tsFile.getIdentifier()}`);
-
-                const compiler = new TypeScriptToJavaScriptCompiler(this.template.getModelManager(),
-                    this.template.getTemplateModel().getFullyQualifiedName());
+                const compiler = new TypeScriptToJavaScriptCompiler(
+                    this.template.getModelManager(),
+                    this.template.getTemplateModel().getFullyQualifiedName()
+                );
 
                 await compiler.initialize();
 
-                // add the runtime type definitions to all ts files??
                 const code = `${Buffer.from(SMART_LEGAL_CONTRACT_BASE64, 'base64').toString()}
-                ${tsFile.getContents()}`
+                ${tsFile.getContents()}`;
 
-                const result = compiler.compile(code);
-                compiledCode[tsFile.getIdentifier()] = result;
+                compiledCode[tsFile.getIdentifier()] = compiler.compile(code);
             }
-            // console.log(compiledCode['logic/logic.ts'].code);
+
             const evaluator = new JavaScriptEvaluator();
-            const evalResponse = await evaluator.evalDangerously( {
+            const evalResponse = await evaluator.evalDangerously({
                 templateLogic: true,
                 verbose: false,
                 functionName: 'init',
-                code: compiledCode['logic/logic.ts'].code, // TODO DCS - how to find the code to run?
-                argumentNames: ['data'],
+                code: compiledCode['logic/logic.ts'].code,
+                argumentNames: ['data', 'currentTime', 'utcOffset'],
                 arguments: [data, currentTime, utcOffset]
             });
-            if(evalResponse.result) {
+
+            if (evalResponse.result) {
                 return evalResponse.result;
             }
-            else {
-                throw new Error('Init failed with message: ' + evalResponse.message);
-            }
-        }
-        else {
-            throw new Error('Only TypeScript is supported at this time');
+            throw new Error(`Init failed with message: ${evalResponse.message}`);
+        } else if (llmConfig) {
+            const executor = new LLMExecutor();
+            const output = await executor.init(
+                {
+                    contractText: this.getContractTextForLLM(),
+                    request: (data ?? {}) as Record<string, unknown>,
+                    modelDefinitions: this.getModelDefinitionsForLLM()
+                },
+                llmConfig
+            );
+            return {
+                state: output.state
+            };
         }
+
+        throw new Error('Only TypeScript is supported at this time');
     }
-}
+}
\ No newline at end of file
diff --git a/src/index.ts b/src/index.ts
index b069039..ab5fbfb 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -16,5 +16,8 @@ import type { TemplateLogic } from './slc/SmartLegalContract.d.ts';
 
 export { TemplateMarkInterpreter } from './TemplateMarkInterpreter';
 export { TemplateArchiveProcessor } from './TemplateArchiveProcessor';
-export { TemplateLogic }
+export { TemplateLogic };
+export * from './LLMExecutor';
 export * from './utils';
+export * from './LLMProviderAdapter';
+export * from './providers/OpenAIAdapter';
\ No newline at end of file
diff --git a/src/providers/OpenAIAdapter.ts b/src/providers/OpenAIAdapter.ts
new file mode 100644
index 0000000..4e51a34
--- /dev/null
+++ b/src/providers/OpenAIAdapter.ts
@@ -0,0 +1,59 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ */
+
+import { LLMConfig, LLMExecutorError } from '../LLMExecutor';
+import { LLMProviderAdapter } from '../LLMProviderAdapter';
+
+type ChatCompletionResponse = {
+    choices?: Array<{
+        message?: {
+            content?: string;
+        };
+    }>;
+};
+
+export class OpenAIAdapter implements LLMProviderAdapter {
+    async completeJson(prompt: string, config: LLMConfig): Promise<string> {
+        if (!config.apiKey) {
+            throw new LLMExecutorError('PROVIDER_ERROR', 'Missing apiKey for OpenAI provider');
+        }
+
+        const baseUrl = config.baseUrl ?? 'https://api.openai.com/v1';
+        const response = await fetch(`${baseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${config.apiKey}`
+            },
+            body: JSON.stringify({
+                model: config.model,
+                temperature: config.temperature ?? 0,
+                response_format: { type: 'json_object' },
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'Return only valid JSON object. No markdown, no prose.'
+                    },
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ]
+            })
+        });
+
+        if (!response.ok) {
+            const text = await response.text();
+            throw new LLMExecutorError('PROVIDER_ERROR', `OpenAI API error ${response.status}: ${text}`);
+        }
+
+        const data = await response.json() as ChatCompletionResponse;
+        const content = data.choices?.[0]?.message?.content;
+        if (!content) {
+            throw new LLMExecutorError('PROVIDER_ERROR', 'OpenAI response missing message content');
+        }
+
+        return content;
+    }
+}
\ No newline at end of file
diff --git a/test/LLMExecutor.test.ts b/test/LLMExecutor.test.ts
new file mode 100644
index 0000000..565845a
--- /dev/null
+++ b/test/LLMExecutor.test.ts
@@ -0,0 +1,49 @@
+import { LLMExecutor, LLMExecutorError } from '../src/LLMExecutor';
+
+describe('LLMExecutor', () => {
+    test('trigger throws typed provider error before implementation', async () => {
+        const executor = new LLMExecutor();
+        await expect(executor.trigger()).rejects.toBeInstanceOf(LLMExecutorError);
+    });
+
+    test('init throws typed provider error before implementation', async () => {
+        const executor = new LLMExecutor();
+        await expect(executor.init()).rejects.toBeInstanceOf(LLMExecutorError);
+    });
+
+    test('parseModelJson parses valid JSON', () => {
+        const executor = new LLMExecutor();
+        expect(executor.parseModelJson('{"state":{"ok":true}}')).toEqual({ state: { ok: true } });
+    });
+
+    test('parseModelJson throws INVALID_JSON on invalid JSON', () => {
+        const executor = new LLMExecutor();
+        expect(() => executor.parseModelJson('{bad json}')).toThrow(LLMExecutorError);
+    });
+
+    test('assertTriggerShape accepts valid output', () => {
+        const executor = new LLMExecutor();
+        const output = executor.assertTriggerShape({
+            response: { accepted: true },
+            state: { counter: 1 },
+            emit: [{ type: 'Event' }]
+        });
+        expect(output.state).toEqual({ counter: 1 });
+    });
+
+    test('assertTriggerShape rejects invalid emit', () => {
+        const executor = new LLMExecutor();
+        expect(() => executor.assertTriggerShape({
+            response: {},
+            state: {},
+            emit: ['bad']
+        })).toThrow(LLMExecutorError);
+    });
+
+    test('assertInitShape accepts valid output', () => {
+        const executor = new LLMExecutor();
+        expect(executor.assertInitShape({ state: { started: true } })).toEqual({
+            state: { started: true }
+        });
+    });
+});
\ No newline at end of file