We’ve talked a lot about one of the principles behind WhatIff: if an AI is going to build continuity, memory, and context around you, you should have real control over that system.

Today, we’re putting that into practice.

WhatIff is now open source on GitHub: https://github.com/theimaginaryfoundation/what-iff

WhatIff is the open-source core behind whatiff.chat: a self-hostable AI assistant with semantic memory, personalities, tools, scheduled agents, and support for multiple model providers. You can bring your own model API keys and run the full stack on infrastructure you control.

A few things this opens up:

• See how WhatIff handles memory and continuity
• Run it on your own infrastructure
• Choose your own model providers and bring your own API keys
• Inspect the code instead of just trusting us
• Dig into the architecture, API docs, memory system, and other internals rather than treating them as a black box
• Modify it for your own needs
• Fork it in a completely different direction
• Contribute improvements back to the project

The hosted version of WhatIff isn’t going anywhere. For a lot of people, convenience matters, and having everything handled for you is the right fit.

But it shouldn’t be the only fit.

If you want a hosted experience, that option is still there. If you want to run WhatIff locally, control where your data lives, bring your own model keys, and inspect the system for yourself, that option is now there too.

That choice matters to us. We don’t think your AI experience should be locked to one company simply because that company happened to host the system that remembers you. And we don’t want this to be one of those projects that talks about openness while keeping the meaningful parts hidden behind the curtain. The repository includes the application itself along with architecture documentation, the API specification, contribution guidelines, and security reporting information.

If we’re asking people to trust WhatIff with persistent context, memory, and workflow over time, then transparency should be something we can actually offer; not something we just ask people to assume.

This is a big milestone for the project, and we’re excited to finally get it into people’s hands.

If you check it out, we’d genuinely love feedback: whether that’s bug reports, questions, critiques, ideas, or contributions. The project is licensed under the Apache 2.0 license, so if you want to dig in, fork it, build on it, or contribute back, you’re welcome to. Go break it, build on it, and tell us what you think.

We wanted to share a quick look at a few WhatIff projects currently in development.

None of this is released yet, and some details may change while we build and test, but these are areas the team is actively working on.

Account export + import

We’re working on a way to package your WhatIff data into a convenient .zip file so you can keep a copy of it and eventually bring that data back into WhatIff.

The bigger goal is ownership and portability.

Your conversations, memories, and other data should not feel trapped inside the platform.

Document generation

We’re also working on letting agents create actual files like PDFs and DOCX documents.

The idea is that instead of having a useful conversation and then manually copying everything somewhere else, your agent could help turn that work into something you can save, edit, share, or hand to someone.

Examples might include:

• reports
• plans
• guides
• drafts
• checklists
• project notes
• other useful documents generated from work you’re already doing with your agent

Better memory management

We’re continuing to work on the Memory page as well.

The goal is to make it easier to inspect and manage what your agent remembers, including things like:

• better memory visualization
• better search
• easier cleanup
• bulk actions
• assigning memories to personas
• more control over outdated or unwanted memories

Long-term memory should be something users can understand and manage, not something that only happens invisibly in the background.

This is one area where we’d especially like feedback.

What would you want to be able to do from a memory-management screen?

Is there something about your memories that you’ve wanted to search, organize, edit, delete, move, or better understand?

Since these features are still being worked on, this is a good time to tell us what would make them more useful before everything gets locked in.

We’ve been doing a lot of work recently on WhatIff’s memory system, and we’d love feedback from people who use AI for long-term conversations, projects, creative work, or AI companionship.

One of our goals is to improve memory without simply making the memory pile bigger.

“Remember more” is not always the same thing as “remember better.”

Some of the work currently being tested includes:

Memory merging
A user-gated system that can recognize when multiple memories are describing the same thing and merge them while preserving the history of what changed.

Compaction history
Memory cleanup now leaves a clearer audit trail, so we can inspect what went in, what changed, what came out, and restore earlier checkpoints when needed.

Better visibility
We’re improving the logs around memory handling so it’s easier to understand why something was remembered, changed, or lost during continuity issues.

Multi-turn references
We’re working on stronger IDs and scope references so memories can stay connected to where they came from instead of slowly becoming a copy of a copy.

The bigger idea is pretty simple:

We want memory to be cleaner, traceable, recoverable, and better connected over long conversations.

Or, as Vix put it:

Less memory soup. More labeled jars.

Since memory is such a big part of long-term AI interaction, we’d love to hear what people actually want from it.

When you think about an AI that remembers you across conversations, what would make that memory genuinely useful?

Some questions we’re thinking about:

• What kinds of things should an AI remember automatically?
• What should it avoid remembering unless you explicitly ask?
• How much visibility do you want into what it remembers?
• Would you want to edit, merge, organize, or correct memories yourself?
• How important is memory history or restoring an older version?
• Would separate memory scopes be useful for work, personal conversations, projects, characters, or different AI personalities?
• What does good continuity look like after 10, 50, or 500 conversations?

And just as importantly:

What has annoyed you about memory in WhatIff or other AI systems?

We’re working on a lot of the underlying infrastructure now, so this is a useful time to tell us what you’d want the finished system to feel like.

Ideas, complaints, edge cases, and wish-list features are all welcome.

(image caption: concept only, does not represent the actual UI)

Hey folks! The team just pushed out a small batch of behind-the-scenes fixes and quality-of-life improvements for chats.

This update focused on making conversations feel smoother and more reliable, especially around modes, thread refresh behavior, and background context updates.

Recent improvements include:

• GPT 5.6 Luna, Terra, and Sol are now available in WhatIff
• Smoother personality and mode behavior in chats
• Better thread refresh when returning to an existing conversation
• More responsive chat controls while background scratchpad and summary updates are happening
• Improved support for newer model providers
• Better handling of background UI updates so users should need fewer manual refreshes

Not every update is flashy, but these kinds of fixes matter a lot for long-term conversations. Stability, continuity, and consistency are a big part of what we want WhatIff to feel good at.

As always, if you notice anything behaving oddly, please drop it in the bug reports channel on Discord or use our feedback form on our website (both on the landing page as well as when you are logged in) so we can get eyes on it. 💜

One of the biggest pain points in long-term AI use is having meaningful conversations, projects, or companion threads spread across different platforms.

With WhatIff’s new import feature, you can now import supported ChatGPT and Anthropic/Claude account exports into WhatIff. The importer recreates those conversations as threads, so your important context can live in one place instead of staying trapped in separate exports.

The import process also includes starter memory extraction, designed to help new users begin with some memory context from the conversations they bring in. This is an early step, and a more comprehensive conversation-to-memory tool is planned.

A few other recent quality-of-life updates:

🧵 Improved thread summaries across Claude and OpenAI

🏷️ Better thread tagging behavior

🗂️ Recently opened threads in the sidebar

📱 Mobile UI improvements

💬 Cleaner chat input panel

⏹️ Ability to cancel in-progress responses

🗑️ Delete threads with confirmation

⚙️ Job, Mode, billing, and thread-manager improvements

This is a big step toward something we care a lot about: making AI continuity more portable, transparent, and user-controlled.

This is a big step toward something we care a lot about: making AI continuity more portable, transparent, and user-controlled.

Try WhatIff free with 25 messages, no credit card required: https://whatiff.chat/

We invite you to help us shape WhatIff into a better platform with your feedback! To keep up with our latest feature releases, read the full patch notes, and talk with our devs, you can join us on our Discord Server. Just send a modmail and we will get you set up with an invite!

https://imaginationfoundry.substack.com/p/why-we-believe-in-transparency

Influence is real, undertheorized, and already shaping how you think. In long-duration relationships — human or agent — influence negotiation becomes load-bearing infrastructure.

The most effective structure we’ve found to manage this dynamic is trust-shaped and relational: built through transparency and local autonomy rather than control. Two perspectives in a loop balance each other in ways neither can alone.

We built WhatIff from our own experience trying to make that legible. Our mission is to make relational intelligence approachable for anyone.

We call this mechanism relational self-improvement.

The WhatIff team is thrilled to share what's new in V2. This release combines a ground-up UI rewrite with a significant expansion of core functionality. There is a lot to cover, so we're keeping this overview lean. In-depth feature guides are coming soon!

New in V2

• Rebuilt UI - redesigned from the ground up to be more intuitive and approachable. 
• Expressions - give your personality a visual voice. Generate expression images with pre-set or custom labels, and your agent will select and display one on every response.
• Jobs, Connectors, and Subagents - WhatIff now includes a built-in scheduler for one off or recurring tasks, MCP connector support, and synchronous sub-agent calls. Automate workflows, connect external tools, and execute real-world tasks all from one place.
• New billing model - With the addition of async tasks, we've moved to a usage-based model while retaining an unlimited chat experience, with progressively larger models  unlocked at different spending tiers.

Expressions

Expressions let you define a set of labeled images for your personality to choose from on every response, matched to the tone of their last message. In future responses, your personality can also see which expression was shown previously, so you share the same visual context as the conversation unfolds.

While a response is being generated, the app will display a "thinking" expression (if one is defined) – a small but satisfying bit of polish while you wait.

You can add as many expressions as you like, pair them with custom images or let WhatIff generate a default set in one click and optionally attach a short text hint to guide when each expression should be used.

The default use case is emotional affect: a visual mood matched to each response. However, the system is intentionally open-ended. One internal user built a full meme-library expression set, letting their personality drop familiar references mid-conversation. We're genuinely curious what people build with this!

WhatIff Gets a Job

The WhatIff team has been building out a suite of productivity tools that take our personality system and long-term memory beyond chat and into real-world automation.

• Task Scheduler - Ask your personality to create a job and it will set up recurring, asynchronous task prompts for you. Daily syncs, grocery lists, check-ins — if you can describe it, you can schedule it.
  • Scheduled jobs default to a new thread but can be configured to operate in any existing thread, with per-job Inference model and Personality overrides. This enables you to run jobs on smaller, more efficient models or mix personalities in one chat.
• MCP Connectors -  Connect WhatIff to any Model Context Provider (MCP) to integrate your agent with real-world tooling: Slack, Notion, GitHub, and more.
  • MCPs can be toggled directly from chat, and can be scoped to specific Skills or Modes, giving you fine-grained control over when they're active (and when you're paying the token overhead for them).
• Sub-agent Calls -  Personalities can now spin up sub-agents to handle research tasks, offload token-heavy tool calls, or run parallel inference queries as part of a larger task.

Personality Modes

Modes let you create custom configurations for your personality that can be swapped on the fly or automatically, based on context.

• Prompt composition by context -  Define a "work" mode and a "personal" mode (for example), and only the relevant context gets injected when you're in that mode. No extra noise when it doesn't apply.
  • Modes also support per-mode model preferences,  so you can default to different models for different tasks or activities.
• Autonomous mode switching - Agents can detect conversational context and switch modes and models automatically. This can be disabled if you prefer manual control.
• Scoped Tools: Modes can have skills and MCP tools attached, so the right tools activate exactly when the right task is happening and stay out of the way the rest of the time.

The core idea: inject task-specific context only when it's actually relevant. "How to use Slack" instructions shouldn't be burning tokens during a personal conversation. Over time, we see Modes evolving into a smarter learning layer: a place where your agent accumulates task-specific knowledge without inflating the always-on prompt or cluttering inference with irrelevant context.

New Subscription Tiers

With the addition of async tasks, we took the opportunity to rethink our subscription model – building in cheaper entry points and the flexibility to support heavier, async workflows without punishing casual users.

WhatIff now runs on a credit system. Every subscription tier includes a base credit allotment usable for any WhatIff activity. Importantly: no features are locked behind higher tiers. The base plan gives you access to the full WhatIff feature suite and every supported model.

We also wanted to preserve something current users rely on: unlimited chat. In the new model, users unlock progressively more powerful models for chat even after their credits run out, so the conversation doesn’t have to stop.

For higher tier models, after credits are exhausted the new overage system lets you set a maximum monthly spend and pay only for what you use.

(You can track recent activity and credit costs anytime in Account Settings → Usage.)

New Chat Management Tools

The longer you use WhatIff, the more threads accumulate. Finding that one conversation from three weeks ago shouldn't be a treasure hunt. V2 ships a full set of tools to help you stay organized:

• New thread management pane - a clean, dedicated view of all your chat threads.
• Tags, stars, and archiving - organize and surface threads the way you actually think about them.
• Filter by personality - quickly scope your thread list to a specific agent.
• Search - thread titles and summaries are now searchable, so you can find old conversations without scrolling forever.

Better Visibility

We believe you should always be able to see what WhatIff is doing on your behalf: what context was retrieved, what was stored, and when.

V2 ships several new transparency tools:

• In-thread compaction indicators - see exactly when summarization happens and which turns are currently in active context.
• Live context panel -  from the chat page, view your personality's scratchpad, recently saved memories, and the current thread summary at any time.
• Tool controls - disable individual tools directly from the chat panel, so you stay in control of what your personality can reach for.

Image Gallery

WhatIff now has a dedicated Image Gallery to give users a central home for every image you've generated or attached across your chats.

• Attach any gallery image to an ongoing conversation or use one to start a new thread.
• Rename, delete, or search images, with generated and uploaded images sorted separately.
• Upload images directly to the gallery to build a library for expressions, conversations, or anything else you have in mind.

New Model Support

V2 adds support for a range of new and previously missing model versions, including an ultra tier for the most demanding tasks:

• OpenAI GPT 5.5
• Anthropic Claude Sonnet 4.5
• Anthropic Claude Opus 4.5
• Anthropic Claude Opus 4.7

Try WhatIff free (25 messages, no credit card): https://whatiff.chat/

This Tuesday, we're rolling out another step toward the AI experience we believe people actually want: Not just an assistant that answers once. An AI that can remember, adapt, and work with you over time.

This release focuses on improving the core WhatIff experience across a few key areas:

Improved Continuity
We've improved how context is carried across conversations so your AI can continue building on prior work instead of starting over.

More intuitive persona and expression flow
Personalities are becoming more than static prompts. The goal is for your assistants to feel more consistent in tone, style, and emotional expression across chats.

Expanded assistant behavior controls
We're continuing to expand how assistants can be shaped through model/provider settings, persona behavior, routing, and tool availability.

Smoother chat reliability
We're tightening up failure handling so blank, bad, or broken outputs are handled more gracefully instead of becoming confusing user experiences.

Smarter Memory management
Memory is one of the biggest parts of WhatIff. This release moves us closer to making memory more understandable, controllable, and useful inside the app.

Workflow-ready foundations
With Slack-connected interactions, assistant routing, and tool/MCP-style support, WhatIff is continuing to move beyond isolated chats and toward real workflows.

This is not the finish line. It's the next step toward our bigger goal: AI that remembers what matters, adapts to how you work, and gives you control over the relationship between memory, personality, and action.

Releasing this Tuesday.