From installto production.

Pick a model adapter

Each provider is a separate package — no SDK bloat from providers you don't use. Install only what you need. Swap providers by changing one config line.

Provider-neutral by design. Capabilities gate both compile-time and runtime access. If an adapter doesn't support a feature — say, embeddings — your code won't compile when you try to use embed(). Swap providers without rewriting agents or workflows.

Give your agent capabilities

An agent without tools is just a chatbot. Add TypeScript tools for your domain logic, pick the right sandbox, and declare what your model can do.

.tools({
  search_docs: {
    description: 'Search internal docs.',
    input: z.object({ query: z.string() }),
    output: z.object({
      hits: z.array(z.object({ id: z.string(), text: z.string() })),
    }),
    handler: async (_ctx, input) => ({
      hits: [{ id: 'intro', text: `Result for ${input.query}` }],
    }),
  },
})
.agents(({ agent }) => ({
  answerer: agent({
    model: 'fast',
    input: z.object({ question: z.string() }),
    output: z.object({ answer: z.string(), citations: z.array(z.string()) }),
    tools: ['search_docs'],
    instructions: 'Search docs before answering. Cite sources.',
  }),
}))

for await (const event of session.agents.answerer.stream({ question: 'How do tools work?' })) {
  if (event.type === 'tool.started') console.log('tool:', event.toolId)
  if (event.type === 'run.finished') console.log(event.output)
}

Orchestrate agents with deterministic logic

Workflows are application-owned orchestration around agents. Sequence them, branch on results, request human approval, and write durable state. The workflow handler owns the process. Agents own the reasoning.

.workflows(({ workflow }) => ({
  research_and_write: workflow({
    input: z.object({ topic: z.string() }),
    output: z.object({ draft: z.string(), approved: z.boolean() }),
    handler: async (ctx) => {
      const research = await ctx.agents.researcher(ctx.input)
      const draft = await ctx.agents.writer(research)
      const review = await ctx.agents.critic(draft)

      if (!review.accurate) {
        return { ...draft, approved: false }
      }

      return { ...draft, approved: true }
    },
  }),
}))

const result = await
  session.workflows.research_and_write.prompt({
    topic: 'Vector databases',
  })

if (result.approved) {
  await saveToKnowledgeBase(result.draft)
} else {
  await flagForHumanReview(result.draft)
}

Remember across runs

Sessions have memory and history. Write JSON blobs the agent can recall. List conversation messages. Persist across restarts with a durable state adapter or the local durable execution bundle.

await session.memory.write('last-topic', { topic: 'tools' })

const lastTopic = await
  session.memory.read<{ topic: string }>('last-topic')

const messages = await
  session.history.list({ limit: 20 })

// Use the local bundle for production-shaped durability
// without adding external infrastructure on day one.

import { defineHarness, localDurableExecution } from '@purista/harness'

const local = localDurableExecution({
  root: './.harness',
})

const harness = defineHarness({ name: 'prod-service' })
  .state(local.state)
  .runtime(local.runtime)
  .sandbox(local.sandbox)
  .workspaceStore(local.workspaceStore)
  .checkpoints(local.checkpoints)
  .build()

import {
  evaluatePromptCandidates,
  evaluateDeterministicScorer
} from '@purista/harness'

const scores = await evaluatePromptCandidates({
  candidates: [
    { id: 'brief', prompt: 'Answer in one short paragraph.' },
    { id: 'detailed', prompt: 'Answer with details and citations.' }
  ],
  items: [
    {
      id: 'policy-1',
      input: { question: 'Can I deploy on Friday?' },
      expected: 'change freeze'
    }
  ],
  runCandidate: async (candidate, item) =>
    runYourAgent(candidate.prompt, item.input),
  scorer: async (target) => evaluateDeterministicScorer({
    type: 'contains',
    path: '/answer',
    value: String(target.expected),
    caseInsensitive: true
  }, target)
})