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. 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 just 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); all calls are under 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

Easiest path: 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: fork 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 clones a template into an editable workflow. 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"

# 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",
    headers=headers,
).json()["data"]
print("Forked to", mine["id"])   # now edit this copy

// 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,
  })
).json();
console.log("Forked to", forked.data.id); // now edit this copy

Reference example: the Insurance pack

The Insurance pack is the live reference pack — the worked example to copy when authoring 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 — track the synced API reference for when they land:

• 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 · Prompts
• Data Shield — the pack-default policy a pack can ship.
• Synced API reference — generated endpoint docs.