agentic-patterns

agentic-patterns (TypeScript)

A compositional agent framework for TypeScript. Agents are built by composing frozen, immutable primitives upward through layers -- from atoms to organisms -- then executed by a runtime with events, gates, workflows, and exporters.

Packages

Package	Description
@agentic-patterns/core	Atoms, protocols, molecules, rendering, organisms
@agentic-patterns/runtime	Runner, events, gates, workflows, transport, multi-agent, exporters
@agentic-patterns/server	Hono HTTP server — routes, SSE, admin API, Claude Code hook bridge
@agentic-patterns/cli	ap — discover agents, chat in terminal, launch dashboard

Runtime depends on core. Server depends on runtime + core. Core never imports runtime.

Quick Start

npm install -g @agentic-patterns/cli
ap init my-agents --provider=anthropic --with-plugin
cd my-agents
cp .env.example .env   # add ANTHROPIC_API_KEY
bun install
bun run dev               # http://localhost:3456

--with-plugin also drops a Claude Code plugin next to your project — open Claude Code in that directory and every one of the 26 lifecycle events (tool calls, permission prompts, subagent spawns, compaction, etc.) streams live into the dashboard's /claude-code page, grouped by session.

Or, skip the CLI and use the library directly:

bun add @agentic-patterns/core @agentic-patterns/runtime ai @ai-sdk/anthropic

import { Persona, Mission, RoleBuilder, AgentBuilder } from "@agentic-patterns/core";
import { AgentRunner, AgentEventBus } from "@agentic-patterns/runtime";
import { anthropic } from "@ai-sdk/anthropic";

const role = new RoleBuilder("assistant")
  .withPersona(new Persona({ identity: "a helpful assistant", tone: "concise" }))
  .build();

const agent = new AgentBuilder(role)
  .withMission(new Mission({ objective: "Help the user" }))
  .build();

const runner = new AgentRunner(anthropic("claude-sonnet-4-20250514"), new AgentEventBus());
const result = await runner.run(agent, "Hello!");
console.log(result.response);

Monorepo Development

git clone https://github.com/pattern-stack/agentic-patterns-ts
cd agentic-patterns-ts
bun install
bun run build
bun run test

Building an Agent

Agents are composed from small, frozen primitives. Each primitive answers one question about the agent's behavior.

Persona -- WHO the agent is

import { Persona } from "@agentic-patterns/core";

const persona = new Persona({
  identity: "a research assistant specializing in data analysis",
  tone: "professional and precise",
  priorities: ["accuracy over speed"],
});

Mission -- WHAT the agent is doing

import { Mission } from "@agentic-patterns/core";

const mission = new Mission({
  objective: "Analyze the provided dataset and produce a summary.",
  success_criteria: [
    "Identify top 3 trends",
    "Include statistical backing",
  ],
  constraints: ["Only use provided data, no external sources"],
});

Judgment -- HOW the agent decides

import { Judgment } from "@agentic-patterns/core";

const sourceQuality = new Judgment({
  domain: "source-quality",
  heuristics: [
    "Prefer peer-reviewed sources",
    "Cross-reference statistics across multiple sources",
  ],
  escalation_triggers: [
    "Contradictory data from equally credible sources",
  ],
});

Role -- reusable agent template

A Role composes primitives into a reusable template. Build one with the fluent RoleBuilder.

import { RoleBuilder, Responsibility } from "@agentic-patterns/core";

const role = new RoleBuilder("research-assistant")
  .withPersona(persona)
  .withJudgment(sourceQuality)
  .withResponsibility(new Responsibility({
    key: "analysis",
    name: "Data Analysis",
    description: "Produce accurate, well-sourced quantitative analysis",
  }))
  .build();

Agent -- role + runtime context

An Agent is a Role instantiated with a Mission and optional context.

import { AgentBuilder } from "@agentic-patterns/core";

const agent = new AgentBuilder(role)
  .withMission(mission)
  .withModel("claude-sonnet-4-20250514")
  .build();

Running an Agent

The runtime package provides AgentRunner, an event bus, and exporters for observability.

import {
  AgentRunner,
  AgentEventBus,
  ConsoleExporter,
} from "@agentic-patterns/runtime";

const bus = new AgentEventBus();
const exporter = new ConsoleExporter(bus);
exporter.start();

const runner = new AgentRunner(model, bus);
const result = await runner.run(agent, "Analyze Q4 revenue trends.");

console.log(result.response);
exporter.stop();

Workflows

The workflow layer provides composable patterns for multi-step and iterative agent execution.

Sequential -- chain agents in order