Run your backlog through
agent workflows — on your machines.
Define the steps, hand the agent a work item, and let evaluation policies decide when work advances. Every step runs in your own devcontainer and leaves artifacts — traces, logs, outputs — you can inspect.
What do you want the agent to do?
Workflows are yours to define — the steps, the models, and the evaluation policies that gate each one. These are the shapes teams usually start with.
Fix bugs from tickets
Ingest a bug from GitHub or Jira. The agent reproduces it in a live browser, the step passes evaluation, and the fix step starts with the repro as context.
Ship backlog features
Write a work item in the dashboard with enough detail to act on. The agent implements it step by step, and evaluation policies gate what counts as done.
Raise test coverage
Point a workflow at under-tested code. The agent writes failing-first tests, and the workflow only advances when the suite actually runs and passes.
Triage and hand off
Let the agent reproduce and document incoming issues — traces, logs, and screenshots attached as artifacts — then hand a confirmed repro to a human.
The workflow layer between your backlog and your machines.
Boboddy coordinates the workflow — steps, evaluation, artifacts — while the execution stays on infrastructure you control.
Work items from anywhere
Create work items in the dashboard, or ingest them from GitHub and Jira. Either way, the agent starts from a description your team actually wrote.
Evaluation decides advancement
Each step reports structured signals, and your policies decide what happens next — advance, retry, or complete. No vibes-based “done”.
Artifacts on every step
Traces, logs, screenshots, and outputs are saved to the step that produced them. Open the Playwright trace the agent captured, right from the execution page.
Your devcontainer, your machines
Workers run each step inside your project's own devcontainer — the same environment your team develops in, on hardware you control.
Bring your own AI
Use the model that fits each step. API keys stay with your workers, so the control plane coordinates the workflow without owning your credentials.
Context in, questions out
The agent reads your business context — personas, product flows, terminology — before every run, and asks for feedback through notifications when it's blocked.
From work item to evaluated result.
Connect a repo, define the workflow, give it work. Workers run every step in your devcontainer, and nothing advances until it passes evaluation.
Connect your repo
Install the CLI and link a repo that has a devcontainer — that exact environment, with your tools and dependencies, is where the agent will work.
# in a repo with .devcontainer/devcontainer.json
$ npm i -g @boboddy/cli
$ boboddy auth login
$ boboddy init
→ devcontainer detected
→ project linked: my-projectDefine the workflow
Steps are typed units of work. Evaluation policies read the signals each step reports and decide whether the workflow advances, retries, or completes.
import { defineStep, definePipeline, z } from "@boboddy/sdk";
import { fixBug } from "./steps";
const reproduceBug = defineStep({
name: "reproduce-bug",
output: z.object({ summary: z.string() }),
signals: { reproduced: { type: "boolean" } },
});
export const bugfix = definePipeline({
name: "bugfix",
stages: [
{ step: reproduceBug, advanceWhen: "reproduced == true" },
{ step: fixBug, advanceWhen: "testsPassing == true" },
],
});Give it work
Create a work item in the dashboard with enough detail for the agent to act on it — or ingest one straight from GitHub or Jira. The agent also reads your project's business context before every run.
Run workers, inspect artifacts
Workers on your machines claim each step, run the agent inside your devcontainer, and stream logs to the dashboard. Every step leaves artifacts you can open — including full Playwright traces.
$ boboddy work my-project
→ worker-01.local connected
→ claimed: reproduce-bug · exec_8f3a
→ devcontainer up · agent session started
→ signal: reproduced = true
→ evaluation passed · advancing: fix-bug
→ artifacts: trace.zip · console.log · banner.pngSelf-hosted by default. No compromise.
Boboddy ships the control plane. You bring the workers. The result is a platform with the polish of a SaaS and the trust boundary of on-prem.
Your code never leaves your network
Workers clone, run, and report from inside your perimeter. Source, build artifacts, and intermediate state stay on your hardware.
Your AI provider, your API keys
Credentials live on the worker, not the control plane. Swap providers per project or per step without giving up keys to anyone.
Runs in your own devcontainer
Each step runs inside your project's devcontainer on your worker — the environment you already trust, with the boundaries you already set.
Pay for compute you already own
Shared execution planes charge for cycles you don't need. Boboddy runs on the machines you have, at the cost you already pay.
Put your backlog on agent workflows you can actually trust.
Define the steps once, then let evaluated agents work through the queue — in your devcontainer, on machines you already control, leaving artifacts at every step.