Orchestrate Complex Tasks with JSON Schema

Wire complex, multi-step tasks together with a single JSON schema. Each node is independently routed, validated, and assembled into one clean result.

Get Started Docker Setup

world-gen.ts

const schema = {
  type: "object",
  instruction: "Defines the technological landscape",
  properties: {
    Level: {
      type: "string",
      instruction: "Categorize technological sophistication"
    },
    Inventions: {
      type: "string",
      instruction: "Describe significant discoveries"
    }
  }
};

// Result:
// {
//   "Level": "Advanced Industrial",
//   "Inventions": "Aether-Steam Engines..."
// }

One Schema. Many Tasks. One Result.

ObjectWeaver is built around a simple idea: complex workflows should be easy to express.

Define your pipeline as a JSON schema. Each field is a task — with its own model, instructions, and dependencies. ObjectWeaver handles the routing, parallelism, and validation so you can focus on what you're building, not the plumbing.

Schema-Driven

Type Safety

Validation at every stage

Multi-Provider

Any LLM

OpenAI, Gemini, local models

Open Source

AGPL-3

Audit code, contribute features

Self-Hosted

Your Infrastructure

Complete control over data

How It Works

Each field in your schema is a node in the network — independently routed, validated, and connected into a single result

Schema Definition

{
  "doc": {
    "type": "object",
    "instruction": "Generate comprehensive documentation",
    "properties": {
      "frontMatter": {
        "type": "object",
        "instruction": "Generate metadata for front matter",
        "model": "gpt-4o-mini",
        "properties": {
          "title": {
            "type": "string",
            "instruction": "Clear descriptive title"
          },
          "tags": {
            "type": "array",
            "instruction": "1-3 technical tags",
            "items": {
              "type": "object",
              "properties": {
                "name": { "type": "string" }
              }
            }
          }
        }
      },
      "levels": {
        "type": "object",
        "instruction": "Multi-level documentation",
        "properties": {
          "beginner": {
            "type": "object",
            "model": "gpt-4o",
            "instruction": "Simple explanations",
            "properties": {
              "introDescription": {
                "type": "string",
                "instruction": "What it does, max 350 words"
              },
              "dataFlow": {
                "type": "string",
                "instruction": "Mermaid flowchart"
              }
            }
          },
          "expert": {
            "type": "object",
            "model": "gpt-5.1",
            "instruction": "Architectural analysis",
            "dependsOn": ["beginner"],
            "properties": {
              "introDescription": {
                "type": "string",
                "instruction": "Design patterns, max 350"
              }
            }
          }
        }
      },
      "requirements": {
        "type": "object",
        "model": "gpt-4o",
        "instruction": "Reverse-engineer requirements",
        "properties": {
          "requirements": {
            "type": "string",
            "instruction": "Markdown table format"
          }
        }
      }
    }
  }
}

Guaranteed Output

7 fields processed in parallel

3 models routed (gpt-4o-mini, gpt-4o, gpt-5.1)

100% valid nested structure

{
  "doc": {
    "frontMatter": {
      "title": "UserManager Documentation",
      "tags": [
        { "name": "user-management" },
        { "name": "database-access" }
      ]
    },
    "levels": {
      "beginner": {
        "introDescription": "## Introduction\n\nThis code...",
        "dataFlow": "```mermaid\ngraph TD\n..."
      },
      "expert": {
        "introDescription": "## Introduction\n\nArchitectural..."
      }
    },
    "requirements": {
      "requirements": "| Requirement Type | Description..."
    }
  }
}

Parallel Field Processing

Multi-Model Routing

Nested Object Support

Field Dependencies

Type Validation

Instruction-Based Generation

Key Features

Schema-driven orchestration that handles the complexity of LLM coordination, validation, and model routing.

Developer-Friendly API

RESTful API with native SDKs for Python, TypeScript, and Go. Define schemas as code with type safety, deploy with Docker. Comprehensive documentation with cURL examples and integration patterns.

Production-Grade Reliability

Built-in exponential backoff retry logic, intelligent rate limiting, and comprehensive error handling. Built with Go for high-performance concurrent processing at scale.

Enterprise Ready

Self-hosted deployment keeps your data in your infrastructure. Commercial licensing with SLAs, architecture consulting, and priority support. Start with AGPL-3, upgrade for commercial products.

Licensing That Scales With Your Business

Start Free: AGPL-3 license for internal tools, development, and open-source projects. No restrictions on self-hosted deployments within your organization.

Go Commercial: Building a SaaS product or proprietary service? Commercial licensing removes open-source obligations and includes enterprise-grade support, legal protection, and compliance assistance.

Architecture review and optimization consulting
Custom feature development for enterprise needs
Direct Slack/Discord channel with core team
Production incident support with guaranteed response times

Compare Licenses Enterprise Plans

Community EditionFree forever for internal use

Commercial LicenseBuild proprietary products & services

Enterprise SupportSLAs, warranties & priority assistance

Connect Your Tasks. Ship Faster.

Stop hand-wiring LLM calls and parsing fragile outputs. Describe your workflow as a JSON schema, and let ObjectWeaver orchestrate the network of tasks — routing, validating, and assembling results automatically. Deploy in minutes with Docker, scale with confidence.

Deploy with Docker Explore API Examples