Getting Started

Install and configure the Sprinter Platform to build structured intelligence apps.

The Sprinter Platform is a TypeScript framework for building structured intelligence applications. It provides entity management, AI agent orchestration, tool execution, and multi-tenant auth as composable packages.

Install

pnpm add @sprinterai/core @sprinterai/runtime

For Supabase-backed persistence:

pnpm add @sprinterai/supabase

Packages

Package	Purpose
`@sprinterai/core`	Types, store interfaces, builders, module system
`@sprinterai/runtime`	Agent execution, tool registry, chat handler, workflows, evals
`@sprinterai/supabase`	Supabase clients, auth adapter, persistence stores

5-Minute Quickstart

1. Define an entity type

import { defineEntityType, field } from "@sprinterai/core";

const company = defineEntityType({
  slug: "company",
  name: "Company",
  description: "A portfolio company",
  icon: "building",
  schema: {
    type: "object",
    properties: {
      name: field.text({ title: "Company Name" }),
      sector: field.select({
        title: "Sector",
        options: ["SaaS", "Fintech", "Healthcare", "Infrastructure"],
      }),
      revenue: field.currency({ title: "Annual Revenue" }),
      founded: field.date({ title: "Founded Date" }),
      website: field.url({ title: "Website" }),
    },
    required: ["name"],
  },
});

2. Define an agent

import { defineAgent } from "@sprinterai/core";

const analyst = defineAgent({
  slug: "analyst",
  name: "Research Analyst",
  description: "Researches companies and populates entity fields",
  systemPrompt: "You are a PE research analyst...",
  model: "claude-sonnet-4-20250514",
  toolGroups: ["entity", "web"],
});

3. Define a tool

import { defineTool } from "@sprinterai/core";
import { z } from "zod";

const roiCalculator = defineTool({
  slug: "roi-calculator",
  name: "ROI Calculator",
  description: "Calculate return on investment",
  category: "finance",
  inputSchema: z.object({
    investment: z.number(),
    returns: z.number(),
  }),
  execute: async (input) => {
    const { investment, returns } = input as { investment: number; returns: number };
    const roi = ((returns - investment) / investment) * 100;
    return { roi: `${roi.toFixed(1)}%` };
  },
});

4. Compose into a module

import { defineModule, defineApp } from "@sprinterai/core";

const dealFlow = defineModule({
  name: "deal-flow",
  description: "Deal pipeline management",
  entityTypes: [company],
  agents: [analyst],
  tools: [roiCalculator],
});

const app = defineApp({
  name: "portfolio-intel",
  description: "PE portfolio intelligence platform",
  modules: [dealFlow],
});

5. Create a runtime

import { createPlatformRuntime } from "@sprinterai/runtime";
import { createSupabaseStores } from "@sprinterai/supabase";

const stores = createSupabaseStores(supabaseClient, tenantId);
const runtime = createPlatformRuntime({ modules: [dealFlow], stores });

Architecture

The platform follows a three-layer architecture:

Core -- types, interfaces, and builders (zero dependencies beyond Zod)
Runtime -- execution engine for agents, tools, chat, workflows
Storage -- pluggable backends (Supabase, in-memory for tests)

Read the Architecture page for the full picture.

Registry

UI components are distributed as a shadcn-compatible registry. Install blocks directly:

npx shadcn@latest add https://ui.sprinterai.dev/r/entity-card.json

Next Steps

Architecture -- understand the two-channel distribution model
@sprinterai/core -- types, stores, builders
@sprinterai/runtime -- agents, tools, chat, workflows
Entity System -- schema/behavior/UI split
Agent System -- defineAgent, resolution, delegation

On this page