LiebWeaver
What is LiebWeaver

A structured orchestration layer for AI agents.

LiebWeaver isn't another wrapper around a chat API. It's a full multi-agent reasoning platform where you design the participants, control who speaks and when, ground them in your own knowledge, and verify every tool call against an immutable contract. Built around persistent agents, structured conversation modes, and a model layer that spans nine providers.

Open workspaceSee what's inside
The core idea

You design the agents. You control the floor. The platform makes the rest verifiable.

Agents are data, not code. Each agent is an XML-defined identity — personality, principles, expertise, voice, tools, sources — that you save, fork, and replay without redeploying anything.

Conversation flow is yours. Manual hand-raising, sequential rounds, parallel auto-mode — switch mid-session without losing history. The model never decides who speaks next; you do.

Trust is structural. Every tool invocation runs through disposable verification gates, every model claim is backed by a real test, every source lives in a per-user encrypted index. No hand-waving.

Inside the platform

Ten capabilities that make agent collaboration measurable.

Orchestration core

Persistent multi-agent sessions

Agents are first-class entities — configured once, alive for the whole conversation, sharing a single unified history. Compose a session from any mix of models across nine providers and let them collaborate as named participants instead of personas hidden in a system prompt.

  • One conversation, many agents — each with its own model, identity, and tools
  • Cross-provider composition (e.g. GPT-5 reasoner + Claude critic + local Ollama summariser)
  • Unified central history; no siloed agent memory drift
MIC modes

Four conversation modes you can switch mid-session

LiebWeaver runs the floor instead of letting the model decide. Pick how agents take turns and switch on the fly — start manual for control, flip to AutoRandom to brainstorm, drop into Sequential for a structured round-table — without ever losing context.

  • Manual — you target an agent; always-active observers listen in
  • Sequential — round-robin auto-loops for N rounds
  • Mixed — some targeted speakers, some always-listening observers
  • AutoRandom — independent parallel loops reacting to the latest message in real time
Agent Designer

Compose agents the way you write a brief

A visual studio for designing agents as data. Define who they are, the principles they refuse to cross, the skills they pay attention to, the tone they use, the model and temperature they run on, the tools they can reach for, and the knowledge they ground in — all without touching code.

  • Personality + principles + expertise + voice + temperature
  • Per-agent tools and knowledge attachments at design time
  • Always-active observers that run silently after every turn
  • Save as templates, reuse across sessions, fork and iterate
DAG · Tool integrity

Every tool call passes through disposable verification gates

Tool I/O is the most common attack surface in LLM systems. LiebWeaver wraps every invocation in a Disposable Agent Gate pipeline — three short-lived micro-agents that validate the tool description, the arguments, and the raw output against an immutable canonical contract before the main agent ever sees the result.

  • Gate 1 — description integrity (does the call match the tool's published contract?)
  • Gate 2 — argument integrity (are the arguments semantically valid?)
  • Gate 3 — output integrity (is the response safe to surface?)
  • Backed by ToolWerk's hashed canonical registry — tool drift is rejected at resolve time
MCR · Model Capability Resolver

Model selection backed by real tests, not marketing claims

Every claim about a model — reasoning, tool use, vision, structured output, math, coding — is backed by an automated integration test that LiebWeaver actually runs. Agents can consult the resolver mid-session and adopt a more capable model when the current one isn't up to the task.

  • ~15 capability flags scored across every model in every supported provider
  • Live integration tests; results visible to the user with full transparency
  • User-rating layer on top of objective tests for social proof
  • Agents can switch models mid-conversation when the resolver finds a better fit
Indexed memory

Semantic search across enormous archives, on demand

Long conversations and big knowledge bases break naive RAG. LiebWeaver uses a two-tier index — per-content embeddings for full retrieval and source-level cross-content embeddings for semantic search — so agents can pull exactly the chunks they need from fifty videos without bloating the context window.

  • Per-user SQLite + vector embeddings; data never leaves the user's scope
  • Two retrieval modes — direct content lookup or semantic cross-source search
  • Vocabulary-gap proof: synonyms and concepts, not just keyword matches
  • Embeddings are the index — keyword search is no longer the bottleneck
Resource pipeline

Bring real-world content in with one click

Resource handling is first-class, not bolted on. Drop in a PDF, paste a URL, point at an entire YouTube channel — LiebWeaver extracts text, chunks it intelligently, computes embeddings, and exposes it to agents as either an on-demand RAG tool or always-on system context.

  • YouTube channels, individual videos, URLs, PDFs, raw text
  • Automatic transcript + comment extraction; channel-level batch indexing
  • Per-source recall mode — RAG (agent queries on demand) or always-read
  • Metadata preserved (timestamps, page numbers, like counts) alongside content
Tool ecosystem

Eighteen-plus verified tools, plus MCP

The built-in tool catalogue covers knowledge recall, web search, deep wiki synthesis, charitable steelmanning, structured plotting, video grids, and even a full 2-D optical ray-tracing simulator — and external Model Context Protocol servers plug in over HTTP for anything else.

  • Knowledge — RecallKnowledge, RecallKnowledgeMulti, RecallHistory
  • Reasoning — WikiDeepSearch, Steelman, PlotGraph
  • Domain — OpticalRaySimulation (2-D Monte-Carlo geometric optics), VideoGrid
  • Integrations — YouTube channel/video/transcript tools, MCP HTTP containers
Multi-provider model layer

Nine providers behind one agent definition

Provider differences — Anthropic system prompts, OpenAI tool envelopes, DeepSeek reasoning tokens, Ollama local sockets — are abstracted away. The same agent definition runs on any model the resolver approves, and you can mix providers inside a single session without reconfiguration.

  • OpenAI, Anthropic, Google Gemini, xAI Grok, Alibaba Qwen, DeepSeek
  • Local Ollama (no API key, free), NVIDIA NIM enterprise, HuggingFace router
  • Tool format, vision, reasoning tokens, context length — all unified
  • MCR tracks pricing, capabilities, and latency per model — no manual research
Sessions, templates, scenarios

Freeze a moment. Replay it. Fork it.

A LiebWeaver session is the entire orchestration state — agent rosters, history, mode, attached sources, tool state — saved as a single archivable record. Templates let you publish reusable scenarios; the session catalogue lets you load any past conversation, change one input, and watch a different outcome unfold.

  • Auto-archival on agent-catalogue changes; manual save snapshots on demand
  • Agent templates — Researcher, Critic, Helper, custom — re-usable across sessions
  • Scenario templates — packaged multi-agent setups ready to run
  • Fork & resume — restore a session, edit one agent, diverge cleanly
Why this isn't a wrapper

Built like infrastructure, not a demo.

Enterprise-ready security

Per-user encrypted provider keys, isolated knowledge indexes, immutable platform audit log, full GDPR data-deletion cascade. Every admin action is recorded; every user can wipe themselves.

Domain depth, not just chat

LiebWeaver hosts real domain engines as native tools — including a complete 2-D Monte-Carlo optical ray simulator with reflections, refractions, and scattering. Agents reason about its CSV/JSON output as first-class data.

Architecture you can audit

ASP.NET Core 8 backend, Next.js 16 / React 19 frontend, EF Core persistence, SignalR streaming, ToolWerk canonical tool registry. Every spec lives in /docs — DAG, MCR, indexed memory, session chat — versioned alongside the code.

Get in

Ready to design agents instead of prompting one?

Access is request-based while the platform is in early rollout. Drop a request and we'll get you into a workspace as soon as we can.

Open workspace