Every machine should be agentic.
Bud turns your computer into an agent. Install once, access anywhere. Manage existing agents or build your own.
tool · read file
tests/onboarding.test.ts
Message the agent…
~/app $ npm test
> [email protected] test
✕ onboarding › creates a workspace for new users
Expected: workspaceId to be defined
at tests/onboarding.test.ts:24:18
~/app $ npm test ▋
Three steps to a real agent.
Bud runs a small connector on your machine. You talk to the agent in the browser, and Bud streams back what happens on the real machine.
Install the daemon
Run Bud on the machine where your work already lives: a laptop, dev box, server, lab machine, or always-on workstation.
Claim the machine
Sign in, approve the claim, and your machine appears in the Bud rail with a name, status, and color.
Approve claim
MacBook Pro → your workspace
Start a workstream
Open a thread and ask the agent to work. The terminal, chat, local previews, and files stay together.
Fix onboarding test failure
terminal · chat · preview · files
A workbench for real machine work.
Bud brings conversation, execution, observation, and artifacts into one durable workspace.
Connected machines
See your agent-ready machines in one rail, with online/offline status, display names, and quick switching.
Persistent threads
Each thread is a durable workstream with its own terminal session, history, working directory, and process state.
Live terminal
Watch commands run in the real shell. Send Ctrl+C, resize, type directly, or take over when needed.
Local web previews
Open local loopback apps in a private thread preview so the agent can help with visual work, not just logs.
File viewer
Click referenced files to inspect Markdown, code, and text in context without leaving the workbench.
Model controls
Choose the model and reasoning level per thread from Bud's model catalog.
Context meter
See how full the model-visible conversation is before long-running work is compacted internally.
Ask before risky
When a decision could be destructive or ambiguous, Bud can ask a structured, skippable question before continuing.
Built for the machines where work already happens.
Bud works across development, product review, operations, and personal automation because it starts from the user's real environment.
Run the test suite, inspect the failure, patch the likely file, start the dev server, and show me the local app.
Bud uses the terminal, preserves project state, opens a local preview, and keeps files and output visible.
Pull up the local prototype, check the onboarding flow, and tell me what changed.
Bud runs the app, exposes a private preview, and ties review notes to the actual machine where the prototype is running.
Start the app, open the prototype view, and help me compare behavior after this branch.
Bud coordinates terminal setup and a visual preview so design review does not depend on screenshots or setup notes.
Check the service logs, restart the process if needed, and ask before anything destructive.
Bud keeps terminal work visible, supports interruption, and asks for confirmation before risky actions.
Organize these scripts, run the backup job, and explain anything that fails.
Bud brings agent help to personal machines and self-hosted workflows without moving everything into a hosted sandbox.
Transparent by design.
Bud does not hide the work. The terminal is visible. Tool activity is visible. The transcript is durable. You can interrupt the terminal, cancel the agent, or take over input whenever needed.
User-owned machines
Machines are explicitly claimed by a signed-in human and appear only in that user's workspace.
Visible execution
The agent and the human share the same terminal session. There is no hidden second shell.
Private local previews
Local web views are owner-private and limited to loopback targets such as localhost, 127.0.0.1, and ::1.
User-initiated files
File previews are read-only, short-lived, and opened by the user from referenced file paths.
Interrupt anytime
Stop a long-running command, send Ctrl+C, or type into the terminal yourself.
Three parts, one workbench.
Bud has three parts: a lightweight daemon on the machine, a service that coordinates auth and agent work, and a web workbench for chat, terminal, files, and previews.
Machine daemon
Runs on the user's machine, manages the persistent terminal session, handles safe file preview requests, and opens private loopback web views.
Bud service
Coordinates authentication, device ownership, streaming, persistence, model calls, and agent tool activity.
Web workbench
Combines chat, thread navigation, live terminal output, local app previews, file inspection, model controls, and context visibility.
Technical credibility
- Persistent terminal sessions per thread
- Owner-scoped resources
- Browser-mediated machine claiming
- OpenAI and Anthropic model paths behind a shared catalog
- Long-running conversations with internal context compaction
What Bud does today.
Bud is web-first today, with backend foundations for future mobile clients and notifications.
- Connects an AI agent to a real machine through a small daemon
- Persistent, thread-scoped terminal sessions
- Streams terminal output and agent activity to the browser
- See and type into the terminal yourself
- Private local web previews for loopback apps
- Read-only, user-clicked file previews
- GitHub and Google sign-in
- Browser-mediated machine claiming
- Per-thread model and reasoning selection
- Long-running conversations with internal context compaction
Make your machine agent-ready.
Install Bud, claim your machine, and start a workstream with an agent that can use your real terminal, inspect local previews, and keep the work visible.
Works with your existing projects, scripts, servers, and local apps.