Betaworks’ latest Camp batch bets on AI interfaces, not bigger models

Betaworks’ newest Camp cohort points to a pretty clear shift in AI product design. The interesting startups here aren’t training foundation models. They’re building the layer people actually use, trust, and get frustrated by.

There are 10 companies in the batch, and the pattern is hard to miss: fewer conventional apps, more intent-driven systems, more passive context, more odd input modes, and a lot more pressure on orchestration, memory, privacy, and control. For anyone building AI products, that matters more than another benchmark chart.

Betaworks has earned some attention here. Past Camp cohorts included Hugging Face. So even when a company looks early or strange, it’s still worth reading the batch as a signal.

Software starts disappearing behind intent

Several companies in the cohort are pushing at the same shift from different directions.

Telepath wants a computer without apps. You tell the system what you want, and it figures out which tools, services, and APIs to call. Feather is aiming at long-running workflows with natural language as the control layer. Primitive turns rough voice notes into structured tasks that sync with tools like calendars and Notion. Putty, still in stealth, appears to be working on ambient memory and low-friction interaction.

That cluster matters because it points to the next hard problem in AI software: building a reliable control plane across models, tools, and stateful systems.

By now, plenty of products can fake the assistant demo. Wrap an LLM around a prompt box, add a few integrations, and it looks plausible for five minutes. The hard part starts when the system has to remember preferences, carry state across sessions, handle permissions cleanly, recover from failure, and make actions reversible.

That’s distributed systems work with a conversational UI on top.

Telepath and the orchestrator problem

Telepath is the cleanest version of the app-less computing pitch. A user says, book a flight to New York next Thursday after 5 p.m., aisle seat. Under the hood, a planner breaks that into tasks, checks the calendar, queries travel services, applies budget and airline preferences, and handles payment.

Elegant on paper. This is also where a lot of AI products break.

The stack probably looks familiar:

• a persistent context_store for preferences, active tasks, and credentials
• a tool registry with capability metadata, auth scopes, and rate limits
• a planner that decomposes intent into steps
• an execution controller that monitors each step and handles retries or rollback

The hard part is reliability. Once a system can send money, update calendars, or message other people, “mostly right” stops being good enough. Tool calls need idempotency. Multi-step actions need checkpointing. Auth has to stay live throughout the task, not just during the initial OAuth handshake. If the planner drifts halfway through, the system has to unwind state without duplicate bookings or partial commits.

That’s why app-less computing looks plausible now, but only if teams treat it like infrastructure. Prompt engineering won’t carry this very far.

There’s also an obvious privacy split. Lightweight intent parsing and classification will increasingly run on-device for latency and trust. Heavy reasoning and integration logic still makes more sense in the cloud. Hybrid systems fit the problem. Pure cloud feels invasive and slow. Pure on-device runs into limits once the workflow gets wide.

Feather shows where natural-language automation gets messy

Feather looks like RPA rebuilt for LLM-era chaos. Think apartment hunting, outreach, listing filters, forms, response tracking, follow-ups. Less brittle macro recording, more flexible orchestration.

That’s appealing because old-school RPA breaks the minute the interface shifts. Natural language introduces a different failure mode. Users leave instructions underspecified. Websites change structure. Contact flows fail silently. The LLM fills in too much, or not enough.

So the stack matters. A product like Feather probably needs:

• structured extraction from freeform instructions
• strict schema validation between steps
• a real workflow engine such as Temporal or Dagster
• connectors for email, messaging, browsing, scraping, and forms
• cost controls around inference and repeated fetches

That last point gets ignored in demo culture. Long-running autonomous tasks can get expensive fast, especially when they scrape constantly, re-rank results, and keep looping through inference. Good teams will cache aggressively, compress context, and schedule non-urgent jobs off-peak. Bad teams will find out that agentic automation comes with a real cloud bill.

Primitive and Intension are building for how people actually behave

A lot of AI product design still assumes users will type clean prompts and patiently review outputs. That’s not how most people work.

Primitive’s idea is simple and useful: capture voice notes, parse them into task objects, assign due dates and dependencies, then push them into the tools people already use. If it works, it solves a real problem. People think in fragments. Most software still wants neat forms.

The technical work is less flashy than model demos, but it’s harder than it looks. Streaming ASR, punctuation, temporal parsing, conflict detection, OAuth syncing, and ambiguity resolution all need to behave predictably. “Next Friday” can mean different things based on locale, calendar context, and whether it’s already Friday evening. That’s not a model trick. It’s product discipline.

Intension comes at the same broader problem from another angle. It watches desktop behavior, classifies focus versus distraction, and hides things that pull attention away. That likely means OS-level accessibility APIs, event streams, local time-series models, and a privacy model that doesn’t immediately scare users off.

There’s good instinct in that. AI has spent two years generating more work. Intension is trying to protect the attention needed to finish it.

For developers, the lesson is straightforward: context gathering is turning into a first-class product feature. The question is no longer just what the model can infer from a prompt. It’s also what the product can responsibly observe from its environment.

The strangest ideas are still revealing

Some of the batch is more speculative, but still useful if you want to see where founders think interfaces can go.

Nubrain is working on EEG decoding into speech, text, and even images. Noninvasive EEG is a brutal medium. Signal-to-noise is poor, spatial resolution is weak, and subject variability is high. Anyone selling universal mind-reading from a wearable is selling fiction.

There is still a serious technical path here: filtering and artifact removal, temporal CNNs or transformers, subject-specific fine-tuning, and low-latency inference. The practical version is narrower than the headline suggests. Think assistive communication, constrained vocabularies, and heavily personalized calibration. That would still matter. It just wouldn’t be sci-fi telepathy.

Patina may be the strangest company in the cohort. It’s trying to model smell with protein folding, receptor interactions, and graph neural networks. That pulls AI into computational chemistry, molecular representation learning, and one of the messiest perception problems around.

Olfaction has been under-modeled for a reason. The data is sparse and noisy, and the link between receptor activation and human perception is ugly: many-to-many, context-dependent, full of edge cases. Patina’s approach suggests a stack that combines structural priors from protein models with GNNs over molecular graphs to predict perceptual descriptors or receptor response patterns.

This is serious technical work. It’s also a reminder that multimodal AI shouldn’t stop at text, image, audio, and video. Computing mostly ignored smell because the hardware and datasets were bad, not because smell didn’t matter.

Commerce and simulation show up here too

Some of the startups look less like classic AI tooling, but the same logic shows up underneath.

Presq takes influencer prompts and turns them into manufacturable footwear, with plans to expand into eyewear and home goods. If that works, the value is in translating taste signals into CAD constraints, manufacturability checks, BOM generation, and export formats factories can use without cleanup by hand.

That’s where generative design keeps stalling. Pretty renders are easy. Tolerance checks, material constraints, and heel-load rules are where the work gets real.

Nora tracks shopping behavior at the browser layer. That should raise privacy questions immediately, and it does. Any product that observes shopping behavior that closely needs strong local processing defaults, clear consent, and careful retention policy. Technically, this likely means browser event capture plus product graph matching and spend analysis. As a product, it lives or dies on whether users think it works for them rather than on them.

My Place, by Orange is building simulations of daily life for play and experimentation. That could turn into agent-based modeling, a game-engine layer, synthetic behavior generation, or evaluation environments for AI systems. If the team gets the abstractions right, this kind of work could become useful well beyond entertainment.

What stands out in this batch

Three things jump out.

First, interface is back at the center of AI product work. Models matter, but at the product layer they’re starting to look interchangeable. The harder problems are memory, orchestration, permissions, and trust.

Second, ambient context is becoming standard. Voice, desktop activity, browser behavior, biosignals, and physical-world data are all getting pulled into product design. That can make software better. It also widens the blast radius when privacy or security is sloppy.

Third, the teams that win here probably won’t be the ones with the fanciest model stack. They’ll be the ones that handle boring, unforgiving problems well:

• state management across long-lived tasks
• auth scoped to intent and action, not just app login
• local-first processing where privacy matters
• workflow recovery and rollback
• UX for ambiguity, review, and human override

That work isn’t glamorous. It does decide whether these products are usable.

Betaworks’ latest Camp batch feels more coherent than most startup cohorts. The ideas range from practical to fairly far out, but the premise is consistent: if AI changes computing, users will feel it first in the interface layer. At the point where a vague human intention hits a system and either becomes useful action or turns into a mess.

Most AI products still make a mess. That’s why this cohort is worth watching.

What to watch

The caveat is that agent-style workflows still depend on permission design, evaluation, fallback paths, and human review. A demo can look autonomous while the production version still needs tight boundaries, logging, and clear ownership when the system gets something wrong.