Solution Packs

A Solution Pack is a domain bundle of agents, workflows, Squads, and prompts — shipped as pure JSON and installed into your instance with one API call. The TurfAI website calls these Domain Packs.

Packs solve the "blank page" problem: instead of building from scratch, you install production-tested components and customize only what you need.

Because a pack is just configuration, it is LLM-agnostic (each agent carries its own model, so a pack runs on Vertex, OpenAI, Anthropic, or self-hosted models) and on-prem-compatible (installing a pack is an API call, not a code deploy — nothing leaves your infrastructure).

What a pack is

A pack bundles four kinds of components that build on each other:

1. Prompts — the system instructions that encode a pack's domain expertise (extraction schemas, analysis rubrics, communication templates). Everything else references them.
2. Agents — single-purpose AI workers, each with a goal, tools, and a prompt_title pointing at one of the pack's prompts (e.g. an intake agent that extracts structured claim data from any input).
3. Workflows — multi-step automations chaining agents, decisions, integrations, and human checkpoints (e.g. claims triage end to end).
4. Squads — multi-agent teams for the most complex tasks (e.g. an underwriting squad that produces a full recommendation memo).

Install seeds components in dependency order (prompts → agents → workflows → squads), so every reference resolves. The core platform and packs evolve independently: engine improvements benefit every pack, and packs ship new content without a platform release.

The pack manifest

Every pack is a single bundle with a manifest plus one array per component type. The manifest is the pack's identity card; the solution-pack registry stores it verbatim.

A bundle excerpt (the Insurance pack, trimmed):

{
  "manifest": {
    "name": "Insurance Pack",
    "slug": "insurance",
    "version": "2.0.0",
    "description": "Complete insurance operations pack: claims intake, underwriting, complaints, fraud, issuance, renewals.",
    "category": "industry",
    "icon": "🛡️",
    "color": "#1e40af"
  },
  "prompts":   [ /* prompt definitions */ ],
  "agents":    [ /* agent definitions  */ ],
  "workflows": [ /* workflow templates */ ],
  "squads":    [ /* squad definitions  */ ]
}

Per-component shapes

Each array entry is the same shape you'd POST to that component's own endpoint. Install seeds them for you and tags each with pack_slug + pack_version.

Agent (agents[]) — see Agents:

{
  "slug": "insurance-fnol-intake",
  "name": "FNOL Intake Agent",
  "description": "Extracts structured claim data from form, email, voice transcript, or document.",
  "goal": "You are a specialist insurance claims intake agent…",
  "prompt_title": "Insurance FNOL Intake",
  "available_tools": [],
  "model": "vertex",
  "temperature": 0.3,
  "max_iterations": 10,
  "conversational": true
}

Workflow (workflows[]) — a workflow template; see Workflows:

{
  "slug": "insurance-claims-intake",
  "name": "Claims Triage",
  "description": "FNOL receipt → routed, acknowledged claim.",
  "category": "ai-processing",
  "difficulty": "intermediate",
  "definition": { "nodes": [ /* … */ ], "edges": [ /* … */ ] }
}

Squad (squads[]) — members reference agent slugs; see Squads:

{
  "slug": "insurance-claims-settlement-squad",
  "name": "Claims Settlement Squad",
  "process": "sequential",
  "max_total_iterations": 50,
  "agents": [
    { "slug": "insurance-evidence-collector", "role": "Evidence Coordinator", "task": "…" }
  ]
}

Prompt (prompts[]) — see Prompts. String fields are coerced to the prompt column shapes on install (roles → [{ role, prompt }], newline-split instructions, etc.):

{
  "slug": "insurance-fnol-intake",
  "title": "Insurance FNOL Intake",
  "description": "Extraction schema for first-notice-of-loss submissions.",
  "roles": "You are an insurance intake specialist…",
  "outputFormat": "json",
  "version": "1.0"
}

Install a pack

These endpoints are live on the sandbox. Authenticate with a bearer token (see Authentication) and send all calls to the base URL https://apisandbox.turfai.in/api.

List available packs

curl https://apisandbox.turfai.in/api/solution-packs/available \
  -H "Authorization: Bearer $TOKEN"

import requests

BASE = "https://apisandbox.turfai.in/api"
headers = {"Authorization": f"Bearer {TOKEN}"}

packs = requests.get(f"{BASE}/solution-packs/available", headers=headers).json()["data"]
for p in packs:
    print(p["slug"], p["component_count"], "installed" if p["installed"] else "available")

const BASE = "https://apisandbox.turfai.in/api";
const headers = { Authorization: `Bearer ${TOKEN}` };

const res = await fetch(`${BASE}/solution-packs/available`, { headers });
const { data } = await res.json();
data.forEach((p) =>
  console.log(p.slug, p.component_count, p.installed ? "installed" : "available")
);

Install the Insurance pack

The simplest path is to install by slug from the seed library. The response summarises what was created, updated, or skipped for each component type.

curl -X POST https://apisandbox.turfai.in/api/solution-packs/install-by-slug/insurance \
  -H "Authorization: Bearer $TOKEN"

res = requests.post(
    f"{BASE}/solution-packs/install-by-slug/insurance",
    headers=headers,
).json()["data"]

print("Installed", res["pack"], "v" + res["version"])
print(res["summary"])   # { workflows: "7 created…", agents: "14 created…", … }

const res = await fetch(
  `${BASE}/solution-packs/install-by-slug/insurance`,
  { method: "POST", headers }
);
const { data } = await res.json();
console.log("Installed", data.pack, "v" + data.version);
console.log(data.summary);

To install a pack you authored, POST /solution-packs/install with the full bundle JSON as the body instead. Install is idempotent — re-running updates unmodified system components to the latest version and skips anything you've forked.

Customize a pack by forking a component

Pack components install as system components (pack_slug set, forked_from: null). The model is copy-on-write: you make a user-owned copy that survives pack updates, then edit the copy.

• Config-only tweaks (an agent's model, temperature, max_iterations) can be edited on the system component directly — install preserves config fields on update.
• Content changes (prompt text, workflow nodes, squad composition) should be forked: create a copy carrying forked_from set to the original slug, then edit freely. Forked components are never overwritten when the pack updates.

Workflow templates already expose a fork primitive: POST /workflow-templates/:id/instantiate (body { name, customizations }) creates a user-owned draft workflow from a template and returns { workflow_id, workflow, chatbot_id? } — chatbot templates also create a chatbot. (This is a different endpoint from POST /activities/:id/instantiate, which clones an existing workflow into a "(Copy)".) To customize a pack's claims-triage workflow:

# 1. find the installed workflow's id (filter by pack)
curl "https://apisandbox.turfai.in/api/workflow-templates?filters[pack_slug][\$eq]=insurance" \
  -H "Authorization: Bearer $TOKEN"

# 2. fork it into an editable copy, then edit that copy
curl -X POST https://apisandbox.turfai.in/api/workflow-templates/42/instantiate \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "name": "My Claims Triage", "customizations": {} }'

# 1. find the installed workflow by pack
tpls = requests.get(
    f"{BASE}/workflow-templates",
    params={"filters[pack_slug][$eq]": "insurance"},
    headers=headers,
).json()["data"]
tpl_id = tpls[0]["id"]

# 2. fork into an editable copy
mine = requests.post(
    f"{BASE}/workflow-templates/{tpl_id}/instantiate",
    json={"name": "My Claims Triage", "customizations": {}},
    headers=headers,
).json()
print("Forked to", mine["workflow_id"])   # now edit this draft

// 1. find the installed workflow by pack
const list = await (
  await fetch(
    `${BASE}/workflow-templates?filters[pack_slug][$eq]=insurance`,
    { headers }
  )
).json();
const tplId = list.data[0].id;

// 2. fork into an editable copy
const forked = await (
  await fetch(`${BASE}/workflow-templates/${tplId}/instantiate`, {
    method: "POST",
    headers: { ...headers, "Content-Type": "application/json" },
    body: JSON.stringify({ name: "My Claims Triage", customizations: {} }),
  })
).json();
console.log("Forked to", forked.workflow_id); // now edit this draft

Reference example: the Insurance pack

The Insurance pack is the live reference pack. Copy it as your worked example when you author your own. It covers claims intake, underwriting, complaint handling, fraud detection, policy issuance, and renewals.

Key squads:

• Claims Settlement Squad — five agents collaborate sequentially (evidence collection → coverage analysis → valuation → offer drafting → compliance review) to produce a draft settlement offer ready for adjuster sign-off.
• Underwriting Squad — turns a raw broker submission into a fully argued underwriting recommendation memo, cutting submission-to-quote time from days to hours.
• Broker Support Squad — answers coverage questions, quote requests, and renewal discussions with consistent, accurate responses.

Roadmap (coming soon)

The pieces below are modelled but not yet built. To see when they land, track the synced API reference:

• Pack registry & marketplace UI — browse, one-click install, and partner/community packs.
• Export / import — bundle components you've built into a shareable pack (POST /solution-packs/export · import).
• Copy-on-write Customize — one-click fork for any component with upstream diff notifications.
• More reference packs — Legal, Healthcare, and Financial Services, following the Insurance pack as the template.

Related

• Agents · Squads · Workflows & activities · Prompts
• Data Shield — the pack-default policy a pack can ship.
• Synced API reference — generated endpoint docs.