Desearch — AI Search You Can Verify

Founding design for a decentralized AI search platform — brand to product: sources beside every answer, and a dev platform you can adopt in one sitting.

RoleFounding designer — laid the design groundwork for the platform

ScopeBranding · social media assets · developer console · playground

TractionRepeat queries up, developer onboarding down to days after relaunch

AI search gets distrusted for one structural reason: the answer hides where it came from. Desearch — a decentralized search platform spanning a consumer search experience and a developer API — had both halves of that problem, and as founding designer I was starting from zero: no brand, no design language, no product surfaces to inherit. Users read fluent answers they couldn't check, and the developers who'd build on the API had no platform to adopt it through. The brief was really three jobs: give the platform an identity, earn trust in the answer itself, and make the API something a developer can pick up in one sitting.

There were cheaper ways to look trustworthy — polish the answer copy, add confidence disclaimers. The bet I made instead: trust doesn't come from a more fluent answer, it comes from being able to check it. That single decision drove the design language I laid down for the whole platform. Sources stopped being a footnote and became the second pane — a citations deck sitting beside every answer, with each paragraph tagged by the kind of source it came from. The same principle carried into the developer platform: instead of describing the API, let developers run it — generated request code and a live playground on one screen, returning real responses.

After launch, repeat queries rose noticeably, developer onboarding dropped from about a week to days, and API-key activations multiplied. The durable outcome is the groundwork itself: one design language running from the brand and social presence through the search experience to the console and playground — verifiability as the trust story users feel directly, and a developer platform that reads as part of the same product rather than an afterthought.

A dual-pane layout: the natural-language answer on the left, a source-attribution deck on the right. Checking a claim is part of reading, not a separate research task.

Hovering a sentence highlights the exact source snippet it came from — one gesture from claim to evidence, in both directions.

Auto-generated request code (Python / JavaScript / cURL) and a live playground share one screen, so a developer goes from reading to a working call without changing tabs.

Freshness, citation usefulness, and source coverage surfaced as scannable signals on the answer — designed uncertainty instead of apologetic fine print.

The surfaces that carry the story: the answer experience that earns trust, and the developer layer — playground to console — that converts it.

The answer and its evidence share the screen: a citations deck rides beside the summary, and every answer paragraph is tagged with the kind of source it came from.

The citations deck sits beside the answer — posts, articles, papers and threads as scannable cards.

Answer paragraphs are labelled by source type — social, research, news — so provenance reads inline.

Related questions continue the thread without restarting the search.

The playground writes the integration for you: pick tools, model and result type in the UI, and the request code updates live — run it and read the real response on the same screen.

Language tabs — Python, JavaScript, cURL — auto-update the request code.

Live responses return real JSON, with a UI toggle to read them as result cards.

Filters, models and result types are pickable UI, mirrored instantly into the code.

The dashboard treats usage like a product surface: requests, errors and spend share one clock, so the health of an integration and its bill are never a mystery.

Errors trend beside their rate, so a spike reads as signal or noise at a glance.

Balance, spend today and cost per request sit beside usage — billing transparency by default.

Per-source activity attributes requests, errors and spend, so a cost always traces to a cause.