keyboard.wtf — A Personal AI That Acts With You, Not Around You

Inspiration

Modern computers are powerful, but using them still means translating every thought into a long chain of tiny actions: switch windows, search, copy, paste, rewrite, verify, and repeat.

I built keyboard.wtf around a simple question:

What if your computer understood your intent while keeping you in control?

keyboard.wtf is a Windows-first Personal AI operating layer, redesigned around NVIDIA Nemotron reasoning on Nebius, durable private memory, safe automation, and verifiable outcomes.

Instead of opening another chatbot tab and manually moving context back and forth, a user can invoke keyboard.wtf from anywhere, provide text or selected context, ask for help, research a topic, improve writing, or begin a safe browser workflow. The goal is not “AI that clicks everything.” The goal is AI that helps the computer feel closer to the speed of thought while preserving consent, privacy, and trust.

This fits the Personal AI Track because keyboard.wtf is designed as a persistent, user-controlled assistant with memory, reusable capabilities, local-first interactions, and explicit tool boundaries.

What It Does

keyboard.wtf combines:

• NVIDIA Nemotron models served through Nebius Token Factory for fast, standard, and deep reasoning.
• Persistent personal memory with working, episodic, semantic, project/entity, and skill memory.
• Optional local Ollama embeddings for semantic memory retrieval without sending embedding requests to a cloud service.
• Tavily-powered research with source provenance, extraction, ranking, citation validation, and durable checkpoints.
• Local Windows voice input with review-before-run behavior.
• Context-aware text invocation, selected-text support, and optional clipboard context.
• Safe Playwright browser automation using a plan → act → observe → verify loop.
• Explicit approval gates for consequential actions such as sending, submitting, deleting, purchasing, or changing account/security settings.
• Emergency stop, cancellation, durable audit records, and crash-safe recovery behavior.
• An opt-in Nebius Serverless research worker path with encrypted work items, version-pinned secrets, signed results, and deployed-worker canary verification.

How We Built It

keyboard.wtf is built as a native Windows .NET 8 application with a WPF desktop shell and a separate deployable .NET worker.

The reasoning layer uses NVIDIA Nemotron through Nebius Token Factory. Requests are routed across Nano, Super, and Ultra tiers depending on the workload, while model identifiers remain configurable through environment variables.

The memory system is intentionally more than chat history. Memories carry provenance, confidence, importance, sensitivity, retention metadata, and embedding provenance. If local embeddings are unavailable, keyboard.wtf safely falls back to deterministic lexical, recency, and importance-based retrieval.

For research, keyboard.wtf does not trust a single model response. Nemotron creates a structured research plan, Tavily discovers and extracts sources, evidence is ranked and treated as untrusted input, and final citations are validated against the collected source set.

For browser workflows, keyboard.wtf separates observation from action. It verifies post-action state instead of assuming a click succeeded, detects suspicious prompt-injection patterns, blocks credential and secret typing, and requires explicit approval before consequential actions.

For remote work, we built a Nebius Serverless path with encrypted transport, two-phase dispatch, signed job identity binding, S3-compatible Object Storage, and a dedicated worker signing identity. A signed-worker canary uses a fresh one-time challenge, the exact digest-pinned worker image, an immutable secret version, and a pinned public key to verify worker identity without exposing research content or private key material.

Challenges We Faced

Building an assistant without creating an unsafe automation bot

The biggest challenge was balancing usefulness with control. A system that can operate across browser and desktop workflows must never treat model output, webpage text, or retrieved content as authority.

We addressed this with scoped approvals, one-use approval contexts, emergency stop, prompt-injection handling, post-action verification, and durable audit trails. keyboard.wtf can prepare work, but it does not silently take consequential actions.

Making memory useful without making it invasive

Persistent memory is valuable only if users can trust it. We designed typed memories, sensitivity levels, retention controls, provenance, DPAPI-protected local state, and local-only embedding support. Sensitive and restricted memories are excluded from embedding maintenance by default.

Verifying remote-worker identity

A public key existing in configuration does not prove that a deployed worker holds the matching private key. We built a signed canary flow that binds a proof to a fresh challenge, exact Serverless job, worker image, immutable secret version, and pinned public-key fingerprint. Recording readiness fails closed without a valid protected receipt.

Keeping the setup realistic for judges

The normal desktop app can be built and run locally from GitHub with a Nebius Token Factory key and Tavily key. Optional local memory embeddings use Ollama. Remote Serverless research is deliberately opt-in because it can create provider cost and requires explicit deployment configuration.

What We Learned

We learned that a Personal AI is not defined by the model alone.

A useful assistant needs:

• Context — understanding what the user is referring to.
• Memory — retaining useful information with boundaries.
• Capability — connecting reasoning to real tools.
• Verification — checking whether an outcome actually happened.
• Control — allowing the user to approve, interrupt, correct, or stop.
• Trust — refusing unsafe shortcuts even when they are convenient.

We also learned that local-first design is not a compromise. Keeping voice recognition and optional memory embeddings local improves privacy, resilience, and responsiveness while NVIDIA Nemotron on Nebius provides powerful cloud reasoning when the user chooses to use it.

What’s Next

Next, we want to deepen reusable personal skills, improve memory summarization and retrieval quality, expand safe workflow integrations, and complete live Nebius Serverless qualification with a real deployed-worker canary.

keyboard.wtf is our attempt to make the computer feel less like a collection of disconnected apps and more like one intelligent, trustworthy surface.

The future interface is not just chat.

It is intent, memory, action, verification, and control — working together.

Built With

• agents
• artificialintelligence
• automation
• cryptography
• csharp
• dotnet
• dpapi
• machine-learning
• memory
• nebius
• nemotron
• nvidia
• objectstorage
• ollama
• personalai
• playwright
• privacy
• research
• security
• serverless
• tavily
• voice
• windows
• wpf