Powered by Gemma 4 on Cerebras · Built for live web search and 1000+ app integrations
Most AI assistants hide the work.
You ask for something complex, then get one polished answer back. But for real tasks, that is not enough. You want to know what it searched, what it skipped, what it plans to do next, where the output will be saved, and whether the result is actually grounded.
We built Surfyy because we wanted an assistant that does not just chat. We wanted an assistant that turns work into a visible, editable graph.
Surfyy lives on the desktop. You press a hotkey, describe the task, attach context or speak naturally, and Surfyy builds a graph of agents: search, qualify, extract, write, verify, push to GitHub, deploy, create a workspace table, or hand the task to an app integration.
It feels less like asking a chatbot for help and more like opening an operating layer for the work itself.
These are the three showcase workflows for the demo. They are designed to run with live provider calls, not hardcoded outputs.
Highlighted command: Search about Cerebras and Gemma 4. Make documentation using just HTML, push it to GitHub by creating a repo and commit, then deploy it using the Vercel CLI.
Use case: Fresh Web Dev Client Finder
Surfyy searches the internet for web development client posts from the last 2 days, qualifies each lead, and returns a source-backed outreach list.
Prompt
Find web development clients from the internet that posted in the last 2 days.
Do not hardcode anything. Search live sources, qualify each lead, and return a useful outreach list.
Graph behavior
- Searches fresh web sources at runtime.
- Filters for posts from the last 2 days.
- Extracts client name, requirement, source URL, recency signal, contact path, and pitch angle.
- Verifies that every lead is traceable to a live source.
Use case: Research to deployed documentation
Surfyy researches Cerebras and Gemma 4, writes a plain HTML documentation page, creates a GitHub repo, commits the page, and deploys it with the Vercel CLI flow.
Prompt
Search about Cerebras and Gemma 4. Make documentation using just HTML,
push it to GitHub by creating a repo and commit, then deploy it using the Vercel CLI.
Graph behavior
- Searches current Cerebras and Gemma 4 information.
- Generates a single-file HTML documentation page.
- Creates a GitHub repository through connected app actions.
- Commits the generated page.
- Runs deployment through the Vercel CLI flow.
- Returns the repo URL, deployment URL, and run proof.
Use case: Job Search to Workspace Table
Surfyy finds 50 potential jobs, extracts emails or contact paths, deduplicates the results, and formats everything into a complete Notion/workspace table.
Prompt
Find me potential jobs from the internet and create a list of 50 jobs with their emails.
Put everything into a properly formatted Notion table.
Graph behavior
- Searches across live job sources.
- Extracts role, company, location, source URL, email/contact path, fit notes, and application status.
- Deduplicates and formats 50 rows.
- Writes the result into a complete Notion/workspace table.
- Keeps source links visible for verification.
- Instant Wake: press the desktop hotkey and Surfyy opens a floating command dock.
- Screen-Aware Context: combine command text, files, voice, and visible desktop context.
- Agent Graphs: broad tasks become visible nodes instead of hidden chains.
- Live Research: search the web at runtime and keep source links attached.
- 1000+ App Integrations: push to GitHub, create workspace docs, write tables, and trigger external actions.
- Timing Proof: store provider timing and run events so speed and execution are visible.
- Secure Boundaries: the renderer only holds the user session; service keys stay in the backend.
System reference: Surfyy captures intent, plans an editable graph, then routes execution through secure backend capabilities and app integrations.
This project is built around one important UX bet: a desktop agent only feels useful when it is fast enough to stay inside your flow.
Graph planning, patching, and node execution all need low-latency structured outputs. If each step feels slow, the graph becomes a report. If each step feels fast, the graph becomes an interface.
- What worked: Cerebras gives Surfyy the speed needed to plan and update graphs while the user is still thinking through the task.
- The proof: Surfyy stores provider timing on runs and events, so the demo can show speed instead of merely claiming it.
- The UX effect: the assistant feels less like a response box and more like a command layer.
Surfyy uses Gemma 4 as the reasoning layer.
- Graph planning: convert broad user intent into typed nodes and edges.
- Graph patching: edit an existing workflow without regenerating everything.
- Structured outputs: return JSON-shaped plans, node outputs, artifacts, and verification states.
- Screen-aware reasoning: use visible context, attachments, and voice commands as part of the plan.
Together, Gemma 4 on Cerebras lets Surfyy turn natural desktop commands into fast, inspectable, runnable workflows.
This project uses a TypeScript monorepo with shared contracts across the desktop and backend surfaces.
- Framework: Electron + Vite
- Frontend: React + TypeScript
- Bridge: typed preload APIs for secure IPC
- Local Key Storage: Electron
safeStoragewhen available - Experience: floating command dock, graph canvas, artifacts, provider readiness
- Framework: Hono on Node.js
- Auth: Supabase bearer token validation
- Storage: graphs, runs, events, artifacts, integrations
- Capabilities: web search, transcription, workspace writing, connected app actions
- Schemas: Zod contracts for graphs, nodes, patches, runs, artifacts, integrations
- Execution: dependency-layer builder for graph runs
- Fixtures: example graphs and patches for validation
- Inference: Gemma 4 on Cerebras
- Persistence: Supabase with RLS
- Integrations: 1000+ app actions
- Testing: Vitest
- Node.js 22+
- npm
- Supabase project
- Cerebras API key
-
Clone the repo
git clone https://github.com/somewherelostt/surfyy.git cd surfyy -
Install dependencies
npm install
-
Create a local environment file
cp .env.example .env
-
Run the Supabase schema
Open the Supabase SQL editor and run:
docs/supabase.sql
Start the backend:
npm run dev:backendStart the desktop app:
npm run dev:desktopThe backend defaults to http://localhost:8787, and the desktop dev renderer runs at http://127.0.0.1:5173.
somewherelostt/surfyy/
├── apps/
│ ├── backend/ # Hono API, auth, provider routes, persistence
│ │ └── src/
│ └── desktop/ # Electron app, overlay, React canvas
│ └── src/
│ ├── main/ # Electron main process + model calls
│ ├── preload/ # Secure bridge
│ └── renderer/ # React UI
├── packages/
│ └── shared/ # Graph schemas, patches, execution layers
├── docs/
│ ├── supabase.sql # Database schema and RLS policies
│ ├── phase-1-examples.md # Fixture notes
│ └── surffy-system-reference.png
├── brand.md # Visual direction
└── package.json
npm run dev:desktop # Start Electron + Vite desktop app
npm run dev:backend # Start Hono backend in watch mode
npm run build # Build all workspaces
npm run typecheck # Type-check all workspaces
npm run test # Run tests- Challenge: build a compelling agentic desktop product quickly.
- Core proof: Gemma 4 on Cerebras makes graph planning and execution fast enough for a desktop command layer.
- Track fit: multiverse agents, because Surfyy coordinates specialized nodes and app actions through a visible workflow.
- Product angle: secure knowledge-work automation where every step is inspectable.
Surfyy is an early hackathon/product build. The foundation is in place: desktop overlay, graph canvas, structured model outputs, provider readiness, Supabase persistence, live search, workspace writing, timing proof, and shared schema tests.
- Maaz - GitHub
MIT License. See LICENSE for details.