A private AI workspace, built to put you in control.
$NOEMA is built around a simple idea: you should be able to use powerful AI without giving up control of your data, your work or where it runs.
That starts with:
- Local AI in your browser or on your own machine
- Cloud models without personal signups or separate provider accounts and API keys
- Wallet-based credits, with clear costs
- Conversations stored locally
- ZKR protection and zero-retention Auto routing for cloud chats
Our vision brings conversations, research, code, images, video, audio and agents into one workspace. Tools for everyone, whether you’re learning something new, creating content, building an app or working on your next idea.
We’re growing toward an open ecosystem people can build on, and eventually a broader network for independent compute.
The experience should stay simple as the possibilities grow. You choose what to create, which tools to use and where your work goes next.
https://t.co/2JNMKL2huw
Project context should belong to you. The latest $NOEMA update brings:
* Shared instructions and files across project chats
* Control over which files enter the conversation
* Web search with linked sources
* Enforced execution policies: on-device only, your hardware only or zero-retention cloud
Your project material stays stored locally. Selected context gets ZKR protection when using cloud AI.
More than remembering the brief. Control over what gets shared and where the work happens.
https://t.co/2JNMKL2huw
ZKR vs Retention
Two complementary controls for different stages of remote AI:
• ZKR limits what information is sent before execution.
• Retention governs how the request is handled afterward.
They complement each other. They are not interchangeable.
Noema keeps getting more useful as a private AI workspace.
The latest build adds saved prompts, memory, video and image support, audio transcription and voice generation, all brought into the same workspace.
The goal is to make $NOEMA useful for more than just chat while keeping privacy and user control at the centre of how the product is built.
Here’s a look at the latest build:
ZKR is easier to understand without the privacy jargon.
Before a supported request goes to remote AI, Noema can detect certain sensitive details and replace them.
The protected request is processed remotely and matching values can be restored in the response afterward. It doesn't turn cloud compute into local compute.
It helps reduce what needs to be exposed when you choose remote AI.
Local execution asks: Does this request need to leave my hardware at all?
Zero retention asks: If it runs remotely, what happens to the request afterward?
Both can matter, but they solve different problems. Privacy becomes easier to reason about when those differences are made explicit.
Three Ways to Run AI
Not every workload should follow the same execution path. $NOEMA gives you multiple ways to run AI from a single workspace:
Your Browser: Run supported models directly on the device you’re using.
Your Machine: Connect to a compatible local model server running on hardware you control.
Noema Router: Access remote models when the task requires additional capability or compute.
The execution path can change with the workload without changing the workspace.
https://t.co/2JNMKL2Pk4
This is very close to the architecture we’re building Noema around.
Run what makes sense on your own hardware. When a task needs more capability, Noema can route it to remote models through a privacy-aware execution path.
One workspace, multiple execution paths with the user in control.
Qwen 3.8 flash is truly impressive, and llama.cpp has been rapidly getting better and better at processing it
columns are: pre-existing prompt, new prompt, generated, input tok/s, output tok/s
This is on my laptop (strix halo). I think we're very close to the point where you can just use local models for a large share of tasks, and for anything more advanced, workflows like "use your local model to orchestrate queries to powerful models so your queries don't leak your personal information" actually become viable.
We’re expanding what you can build inside @noemanetwork
The next release brings richer code previews, an editor and version history, plus project ZIP imports and exports.
Generate something, try it, change it and return to an earlier version when you need to. Then take the files with you.
I want the conversation to lead to something useful that you can keep working on. Your project files and edits stay stored locally in your browser.
We’ve shipped a few workspace improvements to Noema.
Projects, Temporary Chats and Reusable Prompts are now live.
Projects help keep related work together. Temporary Chats give you a clean session when you don’t want it added to your saved chat history. Reusable Prompts make it easier to keep and reuse the instructions you come back to often.
Small pieces individually but together they make Noema feel much more like a workspace you can shape around how you actually work.
https://t.co/2JNMKL2Pk4
Linked projects, files and richer execution are the next step in making Noema more useful as a working environment.
The goal is to keep more context connected to the task. So code, files and project state can work together without constantly rebuilding the same context across separate tools.
That means richer workflows, better continuity and more control over how work moves through the workspace.
Less context switching. More continuity around the work itself. We’ll be sharing more of what we’re building around this over the coming days.
A few things coming to @noemanetwork to make everyday work more easier:
- Projects to keep related chats together
- Temporary chats when you don’t want to save a conversation
- A reusable prompt library for things you do often
I want Noema to fit naturally into how people work. Less repeated setup, easier organisation and control over what stays in your workspace.
Privacy doesn’t always mean forcing every AI workload onto the same execution path.
Sensitive work may be better suited to local execution, keeping the task on hardware you control. More demanding workloads may require remote frontier models or compute beyond what your device can provide.
The question shouldn’t simply be local or cloud?
It should be: Which execution path gives this task the right balance of privacy, capability and compute?
That’s the approach Noema is built around.
Thats exactly what we made sure while building Noema. You don’t have to guess what’s happening behind the scenes.
You can see how your request was routed, what protection was applied and what it cost through execution receipts. And with Auto, cloud requests run through configured zero-retention routes.
Privacy should be something you can see and verifiable.
We're publishing our most detailed threat intelligence report to date.
It covers how people tried to misuse Claude—for cyberattacks, influence operations, surveillance, biology, and building weapons—and how we found and stopped them.
We disrupted every operation in the report, and used the lessons from them to strengthen our safeguards. Where appropriate, we also shared what we found with authorities and other AI companies.
These cases are not typical: we’re highlighting some of the most sophisticated misuse we’ve seen. But they’re especially important to discuss, because they show us where AI misuse is headed, where our safeguards work, and where they need to improve.
We’re publishing this report so others can spot the same activity on their own platforms, and so we can give the public a clearer view of how emerging threats develop.
Read the report: https://t.co/0EJUnYEgfz
Noema ZKR now supports both documents and images in addition to text.
In this example, the withdrawal says completed. The ledger still differs.
$NOEMA compares a receipt image with a wallet export and flags an 8 USDC gap after the stated fee. ZKR protects detected details across both files.
Keep the numbers useful. Check the mismatch. Fictional example.
https://t.co/TwmqzilpZi
With the recent update, we introduced privacy-focused workspace where more of the workflow can happen in one environment.
Generate supported code, preview it directly in-app, iterate on the result, run it again and take the output with you.
Fewer unnecessary handoffs between tools. Greater control over your workflow and context.
When you send a prompt, the model is only part of what matters. The other question is: where does that request actually run?
Locally in your browser? On hardware you control? Or on remote infrastructure?
Each path comes with different tradeoffs around privacy, capability and cost.
Execution should be a choice users can understand.
The model is only one part of the AI experience.
As AI takes on more context and more work, where it runs, what data leaves your device and who controls the execution path become just as important as the model itself.
That’s the layer we think deserves more attention.