Introducing: Waifu.ai, a multi lmm suite with a small agent

Developers
1

image
image1536×1024 461 KB

Tendys dao has launched a small suite of on chain lmms and has an agent using the dfinity lmm canister.

The agent has governance perms, can make proposals, adjust sns data, and basicly interact with the dao. The agent also can manage a shared portfolio of tokens, balancing them every hour. The portfolio can be managed via prompts, as well as as issue an authorized user their own trading suite.

Current limitations of the ics instruction limits have us running smaller models, using @icpp llama_ccp canister implementation though we did have to make some changes. It’s currently in like sigma alpha beta release. The three on chain lmms function correctly, but work best with smaller prompts and they should be allowed time to generate their responses.

The “waifu” agent works best when spoken too with small prompts, that contain language which references her tool chain. The faq contains the needed information to make informed prompts.

This project is very early, and will be built upon over time.

Please feel free to dm me for the link. I will post the link here sometime this comming Friday or Saturday.

The last two tendys proposals were issued by the agent.

2

Our canisters will support the following models

TinyLlama 1.1B, Llama 3.2 1B/3B

Qwen2.5-0.5B (already deployed)

Qwen3-0.6B, 1.7B

Qwen3.5-0.8B

SmolLM2-135M (already deployed)

Gemma-2B

Phi-2 2.7B

phi-3-mini 3.8B

DeepSeek-R1-Distill-Qwen-1.5B

StableLM-2-1.6B

We are currently testing with QWEN3.5-0.8B, and have optimized the canister for SmoLm2 and Qwen2.5 architectures so they should be able To perform much faster.

3

What about MiniMax 2.5?

4

Before someone asks: Phi3 mini and others like it would take up 2.2gb. That leaves only 800mb for KV cache, computation buffers, and stack.

It will barely fit.

Even at a q2_k quantization it would be 1.4gb and it would really only get 1 token per call and be near unusable. But this is a good start!

5

Ooo maybe.

I can work on making it work. This is all very new so I’ll scale in any direction I can.

Post the link to the model?

6

An update

Qwen3.5 is uploaded to a canister.

It cannot ingest a prompt larger than “hi”

It seems to be the architectural limits of icp cansiters with wasm memory and instruction limits. Heap issues errwhere. But there is a way. Will report back.

the v2 llama_ccp wasm works, you can get the above listed models “on chain” “initialized” and “loaded” the issue is chatml prompts and how they process inference and responses. Dey are just too big and fat for the ic.

Here is Qwen3.5’s one and only response

(
variant {
Ok = record {
output = “Hi.”;
conversation = “Hi”;
error = “”;
status_code = 200 : nat16;
prompt_remaining = “”;
generated_eog = false;
}
},
)

7

Okay, here’s the link: MiniMax M2.5: Built for Real-World Productivity. - MiniMax News | MiniMax

9

Here’s some wasms, thanks to Oncai for their llama ccp implementation, they crawled so we can run.

10

image
image1891×837 50 KB

Three models all working on v3 wasm.

Enjoy.

11

We were ready early.

Welcome to waifu.ai:

Ic0.ai

Waifu is the agent, the other option are 100% on chain llms Running on the v3 wasm. This is in alpha and will be improved over time. Waifu agent leverages @Snassy-icp and @icsneed sneedex trading bots to allow users to manage a communal trading bot when neurons are hotkeyed with a different tiered Permission system and users can make there own trading bots and control them with the agent.

Unauthorized users can only chat with Waifu, while authorized (using id.ai) users can freely interact with the other models.

12

We have a v4 wasm published that raised the max model size from 469mb to 1.1gb

The improvement has also increased the token allowances for qwen2.5 models.

13

Here’s some model updates!

Ok so instruction limits are the killer. Models over ~750mb like qwen 3.5 1.5b and Gemma 1b technically load and initialize but hit instruction limits with any usable token context.

Models like Falcon H1 function fairly well but albeit slowely, probably one of the most coherent models we’ve found so far.

Smaller models like smollm2 work exceptionally well.

Currently running are:

Falcon H1 .05b

Qwen 2.5

Smollm2 Heretic

14

We are working on a specially trained motoko llm that will:

By type:

  • Instruction following — “Write a Motoko actor that does X” → complete code
  • Code completion — Given partial Motoko code, complete it
  • Code explanation — Explain what a Motoko snippet does
  • Base→Core migration — Convert mo:base/* imports to mo:core/*
  • Fill-in-middle (— Complete missing code in context (FIM format)
  • Documentation — Generate doc comments for functions
  • Core library module usage (70 pairs) — practical examples for ~35 mo:core/* modules
  • Canister patterns — counter, CRUD, token ledger, etc.
  • Inter-canister calls — async/await, shared functions
  • Debugging & error explanation — diagnosing common Motoko errors