mkd-minju/keural-v2-orchestration

Agent Orchestration Dataset

Status: generation complete. 50,000 / 50,000 target rows. Not yet processed — see Pipeline stage before using this for training.

File: agent_orchestration_final_50000.jsonl (597 MB, one JSON object per line, 50,000 lines).

What this is

Synthetic multi-agent conversation traces for training a model to act as an orchestrator: decompose a user task, delegate subtasks to named sub-agents, then synthesize their independent responses into one final answer.

This was generated because no existing dataset (real or otherwise) has genuine hierarchical agent delegation — everything found during sourcing was either single-agent tool use mislabeled as "agentic" (e.g. zai-org/AgentInstruct, ToolBench, huggingface-KREW/Ko-AgentBench), flat peer-to-peer roleplay with no hierarchy (camel-ai/ai_society), or a benchmark spec with no usable transcripts (AgentCollabBench). Full survey and reasoning: parent project's DATASET_PLAN.ko.md §1.3.

Conversation structure

Every row's conversations is a flat list of turns following this pattern:

1. user (meta.agent_name = "user") — a task, seeded from real topics in the already-collected fluency and tool-calling data (see Seeding below)
2. assistant (meta.agent_name = "orchestrator") — decomposes the task into 2–3 subtasks, one per named sub-agent. Delegation is a JSON array serialized as a plain string in content (see Known schema deviation — this is NOT in the tool_calls field despite the field existing per-turn)
3. assistant × 2–3 (meta.agent_name = "<subagent name>", e.g. researcher, calculator, flight_booker) — each sub-agent answers only its own subtask, independently, with no visibility into siblings' responses
4. assistant (meta.agent_name = "orchestrator") — final synthesis combining all sub-agent responses into one answer to the original user request

Turn count is almost always 5 or 6 (25,077 / 24,922 rows respectively — i.e. 2 or 3 sub-agents). One row (out of 50,000) has only 4 turns — a single-subagent edge case where the generation model returned fewer delegations than requested; this was not filtered out. Treat as a known, negligible-rate artifact rather than a bug to chase.

Row-level schema

{
  "source": "self-generated",
  "license": "cc-by-4.0",
  "share_alike": false,
  "lang": "en",
  "category": "agent_orchestration",
  "conversations": [
    {
      "role": "user" | "assistant",
      "content": "string",
      "reasoning_content": null,
      "tool_calls": [],
      "meta": { "agent_name": "string" }
    }
  ],
  "meta": {
    "generation_model": "furiosa-ai/gpt-oss-20b",
    "prompt_template": "agent_orchestration_orchestrator_v1",
    "seed_source": { "source_dataset": "string", "source_index": 0 }
  }
}

All 50,000 rows are uniform on: source="self-generated", license="cc-by-4.0", share_alike=false, lang="en", category="agent_orchestration", meta.generation_model="furiosa-ai/gpt-oss-20b", meta.prompt_template="agent_orchestration_orchestrator_v1".

meta.agent_name is populated on every turn (required by the parent schema, schema/korean_sft_schema.md §3.3) — 12,744 distinct sub-agent names appear across the dataset (e.g. researcher, calculator, flight_booker, pizza_orderer, SecurityCheck, DanceAnalyst), so this is not a small fixed roster — expect long-tail naming.

reasoning_content and tool_calls are always null/[] respectively on every single turn (0/50,000 populated) — present only because the shared schema requires the field to exist on every turn regardless of category, not because this data uses them.

Known schema deviation (important for encoding)

The parent schema doc says agent_orchestration should use the tool_calls field for the orchestrator's delegation (same as tool_calling category). The actual generator does not do this — generate_03_agent_orchestration.py's call_orchestrator() asks the model for "a JSON array" and stores the raw string directly in content (see assemble_conversation() in that script). If your downstream encoding step (e.g. the planned DeepSeek-V4-Flash <｜DSML｜tool_calls> conversion in DATASET_PLAN.ko.md §3.7(b)) assumes delegation lives in tool_calls, it will silently do nothing for this category — you must parse the JSON out of the orchestrator turns' content yourself, or fix the generator and regenerate.

Seeding

Task topics are not invented from nothing — they're drawn from the already-collected §1.1 (fluency) and §1.2 (tool-calling) datasets, so the underlying requests are grounded in realistic asks rather than purely synthetic. Split across the 50,000 rows:

Seed source	Count	%
01_fluency_en_sampled_60000	32,758	65.5%
02_tool_calling_sampled_50000	17,242	34.5%

meta.seed_source.source_index lets you trace any row back to the exact seed record that prompted it.

Because of this, domain coverage is whatever those two upstream sets happen to contain — general assistant-style requests (bookings, calculations, recommendations, everyday Q&A) rather than a curated topic list. This is not a dedicated technical/coding dataset — a handful of software/tech-adjacent tasks show up incidentally, but if you need strong coding/engineering coverage, source or generate that separately.

Generation method

• 100% self-generated by actually running a multi-agent framework (a top-level agent decomposing work and dispatching to named sub-agents) and logging the resulting delegation trace — not scraped, not templated by hand.
• Model: furiosa-ai/gpt-oss-20b — open-weight (Apache-2.0), served on in-house Furiosa NPU infrastructure via furiosa-llm, not a closed/proprietary API. This avoids any competing-model ToS restriction that closed APIs (OpenAI, Anthropic, etc.) impose on using their outputs to train other models.
• English only, no translation step. This is a deliberate default for synthetic generation (see DATASET_PLAN.ko.md §0.7/§1.3): directly synthesizing fluent Korean with an LLM is a harder, more failure-prone generation task than English, so English is the simpler default; genuine Korean rows are added elsewhere in the parent project only from real Korean-native sources, never from a model asked to "write this in Korean" — that would blur into the "AI-generated Korean data" problem the parent project is explicitly trying to avoid. Practical consequence: a model fine-tuned only on this dataset gets zero direct Korean exposure from it — the parent project's plan relies on a Korean-transfer generalization hypothesis (skills learned in English transferring to Korean via the base model's existing bilinguality) which is evaluated separately, not proven by this dataset alone.
• Sub-agent responses are generated concurrently (independent HTTP calls, no shared context) — by construction, sub-agents cannot see or reference each other's output, only the orchestrator (in its final synthesis turn) sees all of them.
• Generation used 2 parallel furiosa-llm server instances (round-robin) and up to 12 concurrent in-flight conversation generations at a time; failed generations (model output that didn't parse as valid JSON, or got cut off by the token budget before finishing) were skipped and not retried with the same seed — the seed pool is large enough (90,899 seed candidates for a 50,000-row target) that skips don't meaningfully constrain topic coverage, but it does mean seed indices are not contiguous / not 1:1 with final row order.

Pipeline stage (important)

This dataset has only completed generation — it has not gone through the parent project's processing pipeline (DATASET_PLAN.ko.md §3):

• ❌ No deduplication (exact or near-duplicate) run yet
• ❌ No length/tokenizer-distribution check against a real target tokenizer
• ❌ No train/val/test split
• ❌ No final chat-template encoding — role/content structure is intentionally kept raw (per §3's explicit instruction not to bake in any chat template before the final step), so this is not ready to feed directly into a training run expecting a specific prompt format
• ❌ No formal diversity check (n-gram/embedding) or contamination cross-check against eval benchmarks (§4) has been run on this specific file yet
• ✅ Per-row provenance (meta.generation_model, meta.prompt_template, meta.seed_source) is complete, which is what makes the later contamination/audit steps possible

If you're pulling this into a training mix, run it through §3 first (or at minimum: dedup, and decide how delegation JSON in content should be encoded, per the deviation noted above).

License

100% self-generated content, so licensing is entirely at the collecting team's discretion (no upstream license to inherit or conflict with). Currently tagged cc-by-4.0 to match the other permissive, self-generated categories in the parent collection. Repo is currently private.

Provenance / where this came from

Part of the Korean SFT dataset collection project (mkd-minju), §1.3 of DATASET_PLAN.ko.md. Generation script: data-repo/processed/03_agent_orchestration/generate_03_agent_orchestration.py. Formal schema: data-repo/schema/korean_sft_schema.md §3.3.

라이선스 및 저작권 표시

100% 자체 생성 콘텐츠이므로 별도로 상속할 원본 라이선스는 없으며, cc-by-4.0으로 태깅되어 있습니다.

"Keural-v2 Orchestration"은 주식회사 MKD(MKD Inc.)가 만든 데이터셋입니다. 위에 설명한 생성 과정(멀티에이전트 프레임워크 실행 및 위임 트레이스 로깅)은 주식회사 MKD가 수행했습니다.