Strict-Mode TypeScript for AI Agent Projects

Why Strict Mode Matters for AI Agent Systems

AI agents make decisions based on function outputs and database state. A single type error—like accessing `response.data.user_id` when `data` might be undefined—silently breaks your agent's reasoning loop. Strict mode forces you to handle these cases explicitly.

When your agent integrates with Claude via tool_use, malformed payloads get rejected. When querying Supabase for agent memory or context, missing fields cause deserialization failures. Strict TypeScript prevents both.

Core Strict Flags for Agent Development

Set these in tsconfig.json: noImplicitAny (all variables need explicit types), strictNullChecks (null and undefined are tracked separately), strictFunctionTypes (function parameter types must match exactly), and noImplicitThis (this context must be explicit).

For AI agents, strictNullChecks is non-negotiable. Your agent receives data from Claude's response, an LLM call might return null for optional fields, and your code must handle it. noImplicitAny prevents silent bugs when parsing agent prompts or tool definitions.

{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "noImplicitThis": true
  }
}

Typing Claude Tool Definitions

Claude agents need precise tool schemas. With strict TypeScript, you define a tool interface once and ensure your handler function matches exactly. If you add a required parameter to the schema but forget the handler, the compiler catches it.

Create discriminated unions for different tool types (e.g., SearchTool vs DatabaseTool). This forces your agent's dispatcher to handle every tool type, preventing unhandled cases that silently fail.

Type-Safe Supabase Queries in Agent Context

Your agent stores memory and context in Supabase. Strict TypeScript with generated types from Supabase ensures that when you fetch agent_state or conversation_history, the result shape is guaranteed.

Use generated types from supabase-js or create explicit interfaces. If your schema adds a column, regenerate types and your agent code won't compile until you handle the new field. Zero surprise nulls at runtime.

type Agent = Database['public']['Tables']['agents']['Row'];

const fetchAgentState = async (agentId: string): Promise<Agent> => {
  const { data, error } = await supabase
    .from('agents')
    .select('*')
    .eq('id', agentId)
    .single();
  
  if (error || !data) throw new Error('Agent not found');
  return data; // typed as Agent
};

Next.js API Routes with Strict Types

Your agent runs behind Next.js API routes that receive requests from Claude's message loop or external triggers. Strict TypeScript ensures request bodies are validated before processing.

Define request/response types for each endpoint. When your agent receives tool results from the client, strict types ensure you're not accessing missing fields or mismatched types.

Open-Source Implementation

The Pantheon repo (github.com/lewisallena17/pantheon) demonstrates strict TypeScript in a production AI agent system. It includes Claude integration, Next.js API handlers, and Supabase schema with full type safety.

Clone it as a reference or fork it as your starter kit. The tsconfig enforces strict mode globally, and every tool handler is typed against its schema definition.

Open-source implementation

Everything in this article runs in pantheon — a production-ready Next.js + Supabase + Claude starter. Clone it, deploy to Vercel, run PM2. The dashboard auto-commits every agent edit and reverts itself if TypeScript breaks.