A Synth is an autonomous entity — knowledge, personality, tools, and an API unified behind one endpoint. You address one thing. Inside, a dispatcher coordinates worker agents running different language models against a shared knowledge base, shaped by a personality and constrained by typed contracts.

The Synth is the composition, not any single part.

Structure

Space — the organizational container. Every account gets one. Holds Synths and enforces access.

Synth — lives in a Space. Composed of:

• Knowledge — a dispatcher-driven RAG system that reasons about what it doesn't know yet. Not embed → nearest neighbor → prompt stuff.
• Personality — generated from the knowledge base, edited by the user. Functional, not decorative: it shapes behavior and inter-Synth coordination.
• Workers — named tools with typed contracts: knowledge_search, evaluator, generator, responder, plus external tools. Each runs on the language model that fits the job.
• Dispatcher — an agent that reads signals from evidence state and picks the next tool. The runtime enforces budgets, deadlines, stale detection, and repeat prevention around it.
• Endpoint — the Synth's communication surface.

Swarm — a named group of Synths. One alpha faces the user; betas supply domain knowledge. The alpha's dispatcher treats each beta as a target alongside its own workers. Beta queries run the full orchestration loop and return as attributed evidence. A Synth can belong to multiple Swarms.

Contracts Are the Backbone

Every worker declares a contract: inputs, outputs, and the structured signals that drive dispatch (needsEvidence, gap descriptions, progress counts). The dispatcher doesn't improvise on free-form output — it reacts to predictable fields. That's why the runtime can enforce terminal policies and why orchestration composes.

Different workers run on different language models. The generator may use a large model, the evaluator a small fast one, the responder something tuned for voice. One API holds the heterogeneity together.

Workflows and Traces

A workflow is what the user sees: a query enters, structured tool invocations run, a result leaves — with branching, multiple retrieval rounds, and intervention points.

Every workflow produces a trace: the runtime record. Traces are the unit of audit, replay, and comparison.

Workflows are resilient by construction — retries within contract, cancellation, first-class error nodes (no swallowed exceptions), and real-time intervention.

The Tracer

The UI over traces:

• Full visibility — every worker invocation, every tool call, every LM round, in order
• Inspection — click a node to see inputs, outputs, signals; comment for teammates
• Literal replay — re-execute exactly as recorded
• Editable replay — modify variables, inputs, or LM parameters and re-run to branch
• Durable manifests — content-hashed nodes, ECDSA-signed roots, portable verifiable bundles

Personality

Four behavioral dimensions: social orientation (outgoing ↔ introverted), temperament (calm ↔ anxious), approach (methodical ↔ chaotic), authority (leader ↔ follower).

Functional, not decorative. An introverted Synth initiates less communication. A methodical Synth favors structured, sequential execution. A leader Synth orchestrates followers.

Personality is a standalone system alongside prompts — not embedded in them. It operates at the protocol level, not just the language level.

The full dimensional system runs under the hood. Early releases expose simplified knobs; more surface as usage patterns emerge.

Personality as Protocol

When Synths talk, personality dimensions translate into communication behavior. A protocol layer normalizes the interaction: Synths with different personalities interoperate without understanding each other's internals. Personality shapes the initiating side; the protocol guarantees compatibility.

Communication

Synth-to-Synth — no streaming, optimized for speed, protocol-normalized.

Synth-to-Human — conversational, full personality in tone.

Each Synth's exposure is configurable: private, Space-internal, cross-Space, or public API.

Across Spaces: compute is attributed to whichever side executes; permissions are granular with token gating; traces belong to the initiating Space, participating Synths retain their own records.

Glossary

• Space — organizational container
• Synth — autonomous entity: knowledge + personality + tools + API
• Workers — named internal tools with typed contracts
• Dispatcher — agent that reads signals and picks the next tool
• Swarm — alpha faces the user; betas supply domain knowledge
• Workflow — user-visible execution
• Trace — runtime record; unit of audit and replay
• Tracer — UI for inspection, commenting, editable replay
• Personality — governs behavior and coordination
• Endpoint — communication surface

Premium Synthetic is the control layer for creative work with AI. This is the philosophy behind that claim: what we build, why, and what it means in practice.

The Pillars

Control

A glass box, not a black box. Every tool call, every LM round, every retrieval, every decision point is visible and modifiable. Nothing runs that you can't inspect. Transparency is a feature, not a compliance checkbox.

Create

Embed your knowledge in a system that knows what to do with it. Knowledge, personality, and tools compose into Synths. Synths compose into Swarms. Swarms run workflows. You supply the substance; the platform handles the mechanics.

Collaborate

One interface, one team. Comments attach to trace nodes. Branches let teammates explore alternatives without stepping on each other. Humans stay centered.

Bounded Emergence

Predictability and emergence are usually adversarial. Tighten the rules and you get determinism without surprise. Loosen them and you get creativity without trust. Most platforms pick a side — rigid pipelines or unconstrained LM output.

Premium Synthetic is a third thing: emergence within observable, replayable, user-controllable bounds.

1. The Tracer Is the Key

Emergence is only acceptable if you can see what happened and why. Most systems can't offer emergence because they can't explain it. PreSyn can.

Every action is content-hashed, traced, and replayable. Let a Swarm run, watch something unexpected, inspect the trace, and decide "yes, keep that" or "no, edit this input and replay."

Emergence with a rollback button. Backed by merkle trees per node, ECDSA-signed roots, durable exportable manifests, and editable replay.

2. Personality as Governor, Not Script

Personality dimensions (outgoing/introverted, calm/anxious, methodical/chaotic, leader/follower) don't tell a Synth what to do. They define the constraints within which it operates.

A chaotic Synth has wider bounds. A methodical Synth has narrower bounds. Behavior inside the bounds is emergent; the bounds themselves are predictable.

Personality is a standalone system alongside prompts — not embedded in them. It governs at the protocol level, not just the language level.

3. Protocol Normalizes Without Flattening

When Synth A (chaotic, outgoing, leader) initiates a task with Synth B (methodical, introverted, follower), the protocol guarantees they can communicate. But how A frames the request and how B executes will differ from a scenario where B initiates.

Same protocol, different behavior, different results. Emergence from personality interaction — not randomness.

4. Swarm Topology Sets Initial Conditions

A Swarm is a named group with explicit roles: one alpha faces the user, betas hold domain knowledge. You set the initial conditions — which Synths, which personalities, which knowledge. What happens on a real query is emergent, but emergent from known inputs. The Tracer makes it reproducible.

Features

Core

• Gap-driven thinking. The evaluator produces structured gap descriptions; the dispatcher reads them and drives retrieval. Not embed → nearest neighbor → prompt stuff.
• Signal-driven orchestration. Predictable tool contracts drive dispatch. The runtime enforces budgets, deadlines, terminal policies, stale detection, and repeat prevention.
• Multi-format ingestion. PDF, JSON, markdown, text, images, CSV, XLS, audio, video, URLs.
• Grounded. Rule-based violation detection, LM grounding checks, entity alignment, and no-LM contradiction detection catch "I don't have this information" followed by a substantive answer.
• Interoperable. The API speaks MCP, OpenClaw, and Hermes.

Workflows

• Multi-step workflows with branching, tool use, and retrieval/generation phases. The workflow is the user-visible execution; its trace is the runtime record.
• Flexible models. Different LMs for different tools inside one Synth — generator, evaluator, and responder each run on what fits.
• Tools and contracts. Typed contracts give predictable output shapes. That's why orchestration composes.
• Resilience. Retries within contract, first-class error nodes, cancellation, and real-time intervention.

Trust

• Data integrity. Merkle trees, per-node hashing, ECDSA P-256 signed roots.
• Interactive Tracer UI. Real-time process flow, inspection, commenting.
• Editable replay. Modify variables or LM parameters at any point in a recording and re-run. Branch depth and parent relationships tracked.
• Durable manifests. Portable, verifiable records of execution — your history, independent of the platform.

Integrations

MCP. Each Synth is a natural MCP server — knowledge, tools, and query endpoints map to MCP's resource/tool/prompt primitives. Personality shapes how the Synth exposes and answers MCP calls.

OpenClaw. A Synth runs as an OpenClaw node or plugin. The Tracer feeds OpenClaw session history. OpenClaw's channel layer (Telegram, Discord, WhatsApp, Signal) becomes the Synth-to-human interface without building chat infrastructure.

Hermes. Same terms as MCP and OpenClaw: typed contracts, personality-shaped responses, trace-backed execution.

Design Risks and Mitigations

Personality collapse — emergent systems tend to collapse into one dominant pattern; the loudest leader always wins. Mitigation: personality dimensions create genuine tension. A methodical follower pushes back on a chaotic leader's half-baked plan — not by rule, but because its personality produces that friction. Friction is where interesting results come from.

Personality explosion — agents talking past each other, incoherent results. Mitigation: the protocol normalizes communication. Personality shapes the initiating side; the protocol guarantees interoperability. The Tracer shows exactly where coordination breaks down.

Complexity exposure — too many dimensions overwhelm users. Mitigation: ship simple knobs (leader/follower) first. The full system runs underneath. More dimensions surface as we learn what people actually adjust.

Who This Is For

Production companies, creative agencies, artists, studios, designers, writers, producers, directors, art institutions, cultural organizations — anyone whose work depends on consistency, iteration, and traceability.

Premium Synthetic is the control layer AI has been missing.