Desktop applications
Add contextual assistants, document workflows, or operator tools without moving core state out of process.
Native agent systems · C++20
Build agents that belong in your runtime.
Wuwe brings model access, typed tools, reasoning, planning, memory, retrieval, MCP, and controlled execution into one composable C++ framework.
- Language
- C++20
- Release
- 0.1.0
- Builds
- Windows · Linux
- Model
- Composable · Auditable
One runtime, explicit boundaries
Compose the parts you need. Keep ownership of the system.
Each subsystem has a focused contract and can be used independently. Higher-level reasoning and planning APIs compose them without hiding state, policy, or execution traces.
- 01
Model access
OpenAI-compatible APIs, Anthropic, Gemini, and Ollama
- 02
Reasoning and planning
ReAct, reflection, plan execution, budgets, and approvals
- 03
Tools and protocols
Typed dispatch, MCP servers and clients, HTTP and stdio adapters
- 04
State and knowledge
Memory, embeddings, hybrid retrieval, citations, and Qdrant
- 05
Execution and evidence
Capability checks, policy hooks, audit events, and traces
Composable modules
Use one capability or assemble a complete runtime.
Sixteen focused modules share common contracts for events, state, policy, and execution. Adopt them independently, then compose only what the product needs.
Models and orchestration
LLM providers
Unified clients for OpenAI-compatible APIs, Anthropic, Gemini, Ollama, and OpenRouter.
Tools
Typed definitions, dispatch, structured results, and model-facing tool calls.
Reasoning
Observable reasoning loops with budgets, tool use, and execution traces.
Reflection
Critique and iterative improvement backed by pluggable reflection stores.
Planning
Plan generation, persistence, reflection, and controlled step execution.
Orchestration
Flow primitives for composing runtime operations without hiding control.
State and knowledge
Memory
Policy-driven memory with in-memory, file, SQLite, and Qdrant backends.
Knowledge / RAG
Loading, splitting, indexing, retrieval, reranking, grounding, and citations.
Protocols and transport
MCP
Clients, servers, gateways, host runtime, and HTTP, stdio, or process transports.
Networking
Selectable HTTP backends, streaming event parsing, and typed transport errors.
Governance
Capability policy
Explicit capability declarations and policy checks at runtime boundaries.
Approvals
Approval service contracts for actions that require host authorization.
Audit
Structured audit events with configurable sinks and host-owned retention.
Observability
Common event sinks, module observers, traces, and telemetry adapters.
Execution
Controlled execution
Execution registry, policies, path checks, and controlled process tools.
Sandbox
Backend enforcement contracts and explicit platform capability reporting.
A small surface to start
From provider selection to a response in native code.
The same provider abstraction extends to streaming, tool calls, reasoning strategies, and host-owned state.
Get startedmain.cppOpenAI-compatible provider
#include <iostream>
#include <wuwe/wuwe.h>
int main() {
wuwe::llm_config config{.model = "gpt-4.1-mini"};
wuwe::llm_client_factory factory;
auto client = factory.create_shared("OpenAI", config);
const auto response = client->complete("Explain RAII briefly.");
if (!response) return 1;
std::cout << response.content << '\n';
}
Where it fits
Built for products where native integration matters.
Wuwe does not prescribe one application shape. It provides the runtime pieces and lets the host own the experience.
Backend services
Run tool-using and stateful agent workflows behind existing service boundaries and observability.
Developer tooling
Compose planning, MCP, retrieval, and controlled execution for automation and engineering workflows.
Private deployments
Select local providers, persistence, and external services according to the product deployment model.
Documentation
Start with one module. Grow into an agent runtime.
The documentation follows the same path: build first, then compose reasoning, state, protocols, and controlled execution.