One shared memory
Lessons, guidance, and decisions persist across sessions and models — normalized once, available to every agent, whoever's driving.
The QuantWeave platform.
Two products, one core. Weft is the agent operations platform we build everything with — a shared memory and guardrails for AI agents, now becoming a self-hostable tool. QWIEIAS is our flagship: one place to run every partner integration, with a set of services growing inside it. Here's what runs today, and where it's going.
Self-hostable · coming soon
Weft
Weft is the agent operations platform we use to build everything else — and it's becoming a product you can run yourself. Point your AI coding agents at one shared brain: the memory, guidance, decisions, and fault history they build up stay put — across every session, and across every model. Switch from one agent or model to another, and nothing starts from scratch.
Under the hood: a shared store (Postgres + pgvector) reached over MCP and HTTP, with a coordination ledger so parallel agents don't collide, automatic capture of failures and validations, and project + decision (ADR) tracking. It runs against local or cloud LLMs and integrates with your git backend — Forgejo today, GitHub and Codeberg next.
Failures become fixes
Every fault is captured, deduplicated, and linked to the remediation that worked — so the same problem isn't solved twice.
Many agents, no collisions
A live coordination ledger shows who's touching what, so a fleet of agents can work in parallel without stepping on each other.
Your git, your models, your infra
Works with Forgejo today (GitHub and Codeberg next), on local or cloud LLMs, and self-hostable — least-privilege by design.
Where it stands: in daily use building QuantWeave today, and being packaged as a standalone, self-hostable tool.
Live on staging
QWIEIAS
Run all of it from one place. Connect the systems you already have — SAP, Oracle, WMS/TMS, 3PLs, EDI, XML, CSV, JSON — and operate every partner integration from one console: configure partners and endpoints, validate and approve mappings, run workflows, and watch every transaction move through a visible, audited lifecycle.
Under the hood: every format maps to and from one canonical model — the hub — so integration effort scales as N + M (each system once, each partner once), never N × M point-to-point. Adding a trading partner is one mapping pack, one routing rule, one delivery profile — a configuration change, not a project, with zero changes to your ERP.
How it works: Ingest. Learn. Deliver.
Ingest
Connect modern and classic endpoints without rewriting your systems. QWIEIAS accepts partner payloads as-is and keeps the original for traceability.
- HTTPS APIs and webhooks for real-time flows — live today
- SFTP and file-based exchange for “classic” integrations — on the roadmap
- Preserve original payloads alongside normalized data
Learn
Improve mappings over time without constant rebuilds — with humans in control of what reaches production.
- LLM-assisted interpretation with confidence scoring
- Human review for changes that impact production behavior
- Version history to audit and roll forward safely
Deliver
Emit clean outputs wherever they need to go — partners or internal systems — with measurable performance.
- Deliver to partners and internal systems using agreed protocols
- Track what was sent, when, and why (with correlation IDs)
- Make integration performance measurable, not mystical
What you get
Operations console
See every transaction move through the pipeline — status, timing, partner context, and exactly where something failed or succeeded.
- Search by business identifiers (order, shipment, invoice, control numbers)
- Drill into a single run to view each step and outcome
- Link out to your observability stack for deep debugging
Bring your own payloads
Onboard partners without forcing a proprietary format. Send what your systems already produce; QWIEIAS learns how to interpret it and routes it through a canonical internal contract.
- Works with the payloads you already exchange
- Hub-and-spoke normalization into a canonical model
- Human approval to lock in production-ready mapping versions
Resilient & auditable
Built for real-world integration weirdness: retries, deduplication, and a replayable audit trail instead of fire-and-forget flows.
- Automatic retries with backoff for transient partner or network failures
- Idempotent processing to prevent duplicates on replays
- Audit history of workflow outcomes and versioned changes
Secure
Secure by default, with modern authentication and a growing set of partner connectivity options.
- OAuth2/OIDC for API access and console login
- HTTPS APIs today; AS2 and SFTP connection profiles on the roadmap
- Tenant isolation and encryption in transit and at rest
The end goal: turn partner integration from a months-long project into a governed, visible flow you operate transaction by transaction.
Building
Agentic Workflows
Get an agent's judgment exactly where you need it — without routing every decision through a model. An agent runs as a step inside a workflow: it reads the run's context, reasons through the data, returns a clear decision, and hands control straight back to the deterministic engine. The non-determinism is boxed into one step, so your critical path stays predictable.
Under the hood: the agent's decision comes back as a classified outcome — the same routing primitive every other step uses — so where a transaction goes next is still your rule, not the model's. Agents run in a separate lane, so real-time flows never wait on them.
Judgment where you want it
Classify the hard cases — urgent vs routine, exception vs normal, escalate vs proceed — and let the workflow route itself on the answer.
Bounded, not black-box
Every agent decision is logged as a classified outcome tied to the rule that used it. You can see which path a transaction took, and why.
No latency tax
Agent reasoning runs off the critical path, so fast, deterministic flows keep their speed. Put intelligence where it earns its place.
Read-only first, safe by design
Agents start by looking things up, not changing state. Anything that writes goes through the same review and promotion gates as every other change.
The end goal: the discernment of a human reviewer on the cases that need it, with the predictability of a deterministic engine on everything else.
In use internally
Knowledge & Assist
The platform builds institutional memory from every exception — each error, what it means, and the fix that worked. When a transaction fails, parks, or needs review, QWIEIAS already knows whether it's seen this before, and hands over the answer instead of making someone start from scratch. Every resolved incident makes the next one cheaper.
Under the hood: a curated, vector-indexed knowledge base that in-workflow agents query over MCP — the same searchable memory people use is what the agents reason with, retrieved by meaning, not keyword. It reads and proposes; it never changes production on its own.
Every error, explained
Failures arrive with their meaning and the remediation that worked last time — not raw logs and guesswork.
Recurring issues surface themselves
An error you've seen before shows its history — how often, which partners, when — and the fix that resolved it, surfaced by semantic search across past incidents.
One memory, people and agents
Support and the in-workflow agents draw on the same curated knowledge base, so fixes stay consistent and compound over time.
Proposes, never auto-applies
Suggested remediations are authored as proposals and routed through the same governance gates as any other change. "What if" stays safe.
Where it stands: working behind the scenes for our own team today, and opening up over time — so the knowledge that keeps integrations healthy is there when you need it.
On the way
Weave Studio
Design your integration workflows visually, then watch them run exactly as drawn. Weave Studio is where routing, step behavior, and branching are configuration — not code. Assemble a flow from a palette of proven steps, set the conditions, and the same engine you designed against runs it. What you draw is what executes.
Under the hood: every step is a node the engine already knows how to run, and each workflow is a versioned definition — reviewable and diffable, like a config change rather than a rebuild. Adding a capability adds a node to the palette, not a release to the pipeline.
Design is the deployment
Change a workflow, activate the new version, and the next transaction sees it — no compile step, no developer handoff.
Control flow you can see
Conditional branches — if urgent, escalate; if clean, deliver — are edges with named conditions. The logic lives in the diagram, not scattered through code.
A palette of proven steps
Steps like translate, validate, route, and deliver — configurable building blocks you combine to model your own process.
Versioned and traceable
Every definition is a versioned artifact you can review before it goes live, and trace back from any transaction that ran it.
The end goal: the people who understand the integration can shape it — safely, visually, and without waiting on a release cycle.