DevPulse AI

DevPulse AI tutorial

From installation to every screen of the app, with screenshots. Use the index to jump to what you need.

1. Installation

DevPulse AI ships as a Windows installer and a .deb package for Linux. Get it on the download page — just enter your email.

Windows

  1. Download DevPulse AI_0.1.4_x64-setup.exe (recommended). The .msi is for IT-managed installs.
  2. Double-click the file. If you see “Windows protected your PC”, click More info → Run anyway (see below).
  3. Follow the wizard. When it finishes, DevPulse opens and can be started again from the Start menu.

“Windows protected your PC”? That is SmartScreen. It warns about installers that do not have a paid code-signing certificate yet or are not downloaded often — the warning does not mean the file is unsafe. Click More info; the Run anyway button appears. Before that, the browser may also say the file “isn’t commonly downloaded”: in Edge, open the download’s … menu → Keep → Show more → Keep anyway; in Chrome, Keep. To check that the file is the original, compare the SHA-256 on the download page with the output of Get-FileHash "DevPulse AI_0.1.4_x64-setup.exe" in PowerShell.

Linux (Ubuntu, Debian, Mint, Pop!_OS)

In a terminal, in the folder where you downloaded the file:

sudo apt install ./"DevPulse AI_0.1.4_amd64.deb"

apt installs the dependencies (WebKitGTK, GTK 3 and AppIndicator). Then open DevPulse AI from the app menu.

Opened the file in the App Center? It shows “Potentially unsafe — This package is provided by a third party”. The warning appears for any .deb that does not come from Ubuntu’s official repositories (Chrome, VS Code and Zoom get it too) and does not mean the file is unsafe. You can confirm the install there or use the command above, which shows no warning. To check that the file is the original, compare the SHA-256 shown on the download page with the output of sha256sum.

GNOME on Wayland: on first launch, the system asks whether DevPulse may register the global shortcuts Ctrl+Shift+D and Ctrl+Shift+P. Answer that dialog — while it is open (sometimes hidden behind the mini-pill), the rest of the screen does not respond. Find it with Alt+Tab if you cannot see it.

Requirements

  • Windows 10 or 11, 64-bit (WebView2 ships with the system or is installed by the wizard).
  • 64-bit Linux with WebKitGTK 4.1 — Ubuntu 22.04+, Debian 12+ or derivatives.
  • For agent features: Claude Code installed and logged in. Without it, live diffs, proxy spend and the tools still work.

Update

New-version banner at the top of DevPulse AI, with the Install and restart button
New version available: the banner at the top of the panel.

From version 0.1.3 on, DevPulse updates itself. On launch and every 6 hours it checks the website; when there is a new version, a banner at the top of the window offers Install and restart, along with a notification. The app downloads the installer, checks its digital signature and restarts on the new version; on Linux, the system asks for your password to install the package. Later hides the banner until the next version.

In Settings → Updates you can check right away or turn automatic checks off. If you are on a version older than 0.1.3, download the new one from the download page and install it over the old one; data and settings are kept.

Uninstall

On Windows, use Settings → Apps. On Linux, sudo apt remove dev-pulse-ai. Your data lives in ~/.local/share/ai.devpulse.desktop (Linux) or %APPDATA%\ai.devpulse.desktop (Windows) and can be deleted by hand — or beforehand, with the button in Security.

2. First run

When it opens, DevPulse shows the mini-pill at the top of the screen and puts its icon in the system tray. The main panel starts hidden: open it with the pill’s expand button, the tray menu or Ctrl+Shift+D.

Add a project

  1. Open the panel and go to Code.
  2. Click Add project and pick the repository folder.
  3. That’s it: from now on every changed file in the folder shows up in the list with its diff. Folders like .git, node_modules and target are ignored, as is anything in your .gitignore.

Connect Claude Code

Nothing to configure: DevPulse reads the transcripts Claude Code already writes to ~/.claude/projects. Sessions, model, tokens, cost, context and declared intent appear by themselves in Agents and on the pill. To import history, set how many days to read in Settings → Integrations.

To approve edits before they are written, install the hooks in Security and turn on the approval gate.

Where the app lives

  • Closing (×) the panel does not quit the app: it goes back to the tray and the mini-pill reappears.
  • While the panel is open, the floating pill hides and the same bar is docked at the top of the panel.
  • To really quit, use Quit DevPulse AI in the tray menu.

3. Mini-pill

The mini-pill is an always-visible bar with the numbers that matter while the agent works. Every block is clickable and opens the matching panel section.

Full mini-pill
Full mini-pill: budget, burn rate, spend, agents, plan limits and code activity.

What each ring shows

BlockMeaning
BudgetHow much of the active budget (the daily one, if any) is spent. Turns yellow past the alert and red when exceeded. Without a budget, it shows today’s spend and a Set up shortcut.
Burn rateSpend per hour at the current pace and the difference from your 7-day average. The ring fills when the pace reaches twice the average.
Current sessionCost of the agent session working right now (or the latest in the last 24 h). The ring shows its share of today’s spend.
Opus · Sonnet · HaikuOne ring per model with today’s spend and each one’s share. Versions of the same model add up; other models get their own ring.
All modelsToday’s total across all models plus reported-cost adjustments.
AgentsActive sessions over known ones (e.g. 2/3).
Session · All · Sonnet (limits)Claude plan limits: the 5-hour window, the weekly all-models limit and the weekly per-model limit, with the reset time (↻). Yellow from 70%, red from 90%. Hover for details; click to refresh.
Code activityLines added and removed in the session; pulses while the agent writes.
Red buttonKill Switch: stops registered agents (shown when there is something to stop).

Plan limits need Claude Code logged in with a subscription (Pro/Max). DevPulse only reads the token Claude Code already stores and asks Anthropic at most once a minute.

Compact version

The compact button (arrows pointing inward) switches to a minimal pill with today’s spend, the 5-hour session percentage and code activity. The expand button switches back. The choice is also in Settings → Appearance.

Compact mini-pill
Compact version.

Move and snap

Drag the pill by any empty area. Drop it near a screen edge and it snaps to it; the position is remembered. Ctrl+Shift+P shows or hides the pill.

4. System tray

Left-click the tray icon to open the summary: today’s spend compared with yesterday, agents from the last 2 hours and recent files. The three buttons do:

  • Sanitize — finds secrets and personal data in the clipboard text and replaces them with placeholders (e.g. [REDACTED:ANTHROPIC_KEY]), ready to paste into an AI chat.
  • Kill Switch — the same emergency button as on the pill.
  • Open panel — opens the main window.
Tray summary
Summary opened from the tray icon.

Right-click opens the menu: Open summary, Open panel, Open Diff Inspector, Show/hide mini-pill, About DevPulse AI… and Quit.

5. Main panel

The panel has its own title bar (with the overall status — All systems go —, the notification bell and the account), the side menu with the sections and, at the top of the content, the same bar as the mini-pill.

  • Ctrl+1 … Ctrl+9 and Ctrl+0 jump straight to each section, in menu order.
  • Ctrl+B collapses the side menu to icons only.
  • The dot next to the name shows app health: green, yellow (a degraded source, such as a stale exchange rate) or red. Hover for the reason.

6. Overview

Overview
Overview: today’s cards, 30-day chart, agents, code, logs and quick actions.
  • Spent today, Burn rate and Average latency (of calls through the proxy), with the change against yesterday and against the weekly average. A ~ before a value means it is estimated from the price table.
  • Daily spend — the last 30 days with the daily budget line. The Table button shows the same data as rows.
  • Agents — sessions and their states (Running, Idle, Awaiting approval, Paused, Error) and the Stop all button.
  • Recent code activity and Live logs — what changed and what happened, with links to the full sections.
  • Quick actions — count tokens, sanitize the clipboard, generate a commit message and validate JSON against a schema.

7. Code — Live Code Diff Inspector

The Diff Inspector shows, in real time, every file the agent (or you) changed since the session started.

Diff Inspector
Diff Inspector: project, session and agent summary at the top, files and conversation on the left, diff on the right and the project actions in the main sidebar.

The title row holds the project, the session (● marks a session in progress) and the + button, which starts a manual session — handy to take a fresh “snapshot” before asking the agent for something. A session ends by itself after a few minutes without changes (configurable).

On the right of that line is the agent summary: session name, state, context usage and line totals. While the Diff Inspector is open, the Project group in the main sidebar has Generate commit, Approval gate (a green dot on the icon means on) and Add project — also with the sidebar collapsed (Ctrl+B). If the agent is editing the main branch directly, a yellow warning appears.

File list

Each file shows its state — Writing (changed in the last seconds), Modified, Reviewed, Reverted, plus Created and Deleted —, who changed it (the session’s agent or another origin), how long ago and the +/− line totals. When the agent writes a file, it is selected in the list and the diff switches to it.

Viewing the diff

  • Reference: compare against the session baseline (the file as it was when the session started) or HEAD (the last commit).
  • Unified or Split, with syntax highlighting and line numbers for both versions.
  • Mark as reviewed (R) to keep track of what you have read.
  • Open in editor jumps to the right line using the configured command (e.g. code --goto {file}:{line}).

Revert

You can undo a hunk (button on each diff block), the whole file or the whole session (link above the list). DevPulse restores the content from the start of the session — changes made before it are kept — and checks the file did not change while you were deciding. Files created in the session are only deleted if you confirm.

Approval gate

With the Claude Code hooks installed and the gate on, every edit the agent proposes stops before being written and shows up in the Awaiting approval queue, with the diff of what will change.

Edit awaiting approval
An edit awaiting approval, with the time left until the automatic answer.
ActionShortcutWhat happens
Accept changeCtrl+EnterLets the write through. With several queued, there is also Accept all queued.
Request changesCtrl+IOpens a field to say what to change (e.g. “use anyhow instead of unwrap”); the agent gets the comment and tries again.
RejectCtrl+⌫Discards the edit; the agent is told.
Abort session—Denies and stops the agent until you send a new message.

If you do not answer within 5 minutes (300 s, configurable), the agent follows its normal flow. If DevPulse is closed, Claude Code also carries on as usual — the hooks never block your work.

Gate rules

Approving every edit gets tiring — and approving on autopilot protects nothing. In Gate rules (main sidebar, Project group), choose where it is worth stopping. There are three options, per project, that you combine as you like:

  • Always ask for approval — sensitive folders and file types, such as migrations/, infra/, .env* or *.sql.
  • Let through without asking — what does not need review before it is written, such as tests/, docs/ or *.md.
  • Minimum diff size — edits with fewer changed lines (added + removed) go straight through. 0 asks at any size.
Gate rules
Gate rules: always ask, let through without asking and minimum diff size.

Patterns use .gitignore syntax, one per line: migrations/ matches the folder at any level and src/**/schema.rs a specific path. The suggestion buttons add the most common patterns with one click.

Order: “Always ask” beats “Let through”, which beats size. With no rules, the gate stops at every edit. Whatever goes through is recorded in the log and stays in the Diff Inspector, where it can be reverted. When a project has rules, the Gate rules icon turns purple.

Agent chat

Below the list is the session conversation — including what you typed in the terminal. Type in the box and press Enter to send a message to the same session (Shift+Enter adds a line break). Markdown tables are rendered as tables, and Claude Code’s own lines show up too: the end of each response (“Done in 1m 12s · 1 shell still running”), finished background tasks, the recap when you come back and messages sent while the agent was working.

While the agent works — even on a request made in the terminal — Processing… appears with the running tool and the elapsed time, like in the terminal.

When a message sent from here needs permission (installing a package, network access, a command outside the project…), the request shows up right in the chat, with a notification: Allow once, Allow in this conversation or Deny. Without an answer within 5 minutes, the action is denied and the agent continues. An edit held by the approval gate shows there too, with Accept and Reject.

Permission requests made in the terminal also show up in the session chat: answer in the terminal or in DevPulse — Yes, Yes, and don’t ask again or No —, whichever comes first decides; the other side updates by itself.

Ctrl+M (or the expand button next to send) opens the conversation in a bottom panel across the whole window, like the VS Code terminal; the status bar stays at the bottom, below it. Drag the top edge to change its height (it is remembered); the ▲ button or a double-click on the edge maximizes the panel. Ctrl+M, Esc or × put the conversation back in the sidebar.

Chat in the bottom panel
Conversation in the bottom panel, opened with Ctrl+M.

Session open in another terminal? To avoid mixing two histories, DevPulse does not write to a session in use elsewhere and offers a New conversation in this project. Edits requested through the chat are applied directly and show up in the diff.

Generate commit

Builds a message from the diff: it uses what is staged or, if nothing is, the uncommitted changes. The local version follows the configured convention (e.g. Conventional Commits); the AI option sends the diff to Anthropic with your key. Review, edit and confirm to create the commit.

Generate commit
Commit message suggested from the diff.

Diff Inspector shortcuts

J/K (or arrows) next/previous file · N/P next/previous hunk · R mark as reviewed.

8. Flows with Personas

A team of personas takes the task from understanding to commit: Helena (analyst) understands it and asks questions, devs for the project language develop with tests, Rui reviews (Vera joins for security and Dora for databases when needed), Bia runs the final tests and you approve. Each step hands the next a baton with the work done. You only step in for your decisions. A Pro plan feature, free during the trial (Pro · trial badge), with no end date. The personas work in Portuguese.

Flows with Personas board
Board: task queue on the left, the task graph following the baton in the middle, pending items and details on the right, timeline at the bottom.

Needs Claude Code installed. Each persona runs as a claude -p session in a git worktree of its own for the task — your main repository does not change until you decide. Never pushes: that stays with you.

Board

On the left is the queue, in four groups: In progress, Queued, Acceptance and Finished. Each task shows its status, who is working now, progress, cost in R$, commit mode and, when relevant, the number of pending items, open findings and the flow changed tag (a persona swap or a reviewer that joined along the way).

In the middle, the graph shows each step: blue running, purple with questions, amber your turn, green done, red rejected. Walked links turn solid and the one carrying the baton is animated. Following the baton, the camera frames whoever is working or waiting for you; panning or zooming turns it off, and Follow again brings it back. Click a node to see, on the right, its Summary (rounds, hat, cost and its pending item), the Baton received and sent in each round and the Log. With no node selected, the right side shows the task summary: flow, branch, worktree, cost, sides and acceptance criteria.

The top bar shows the selected task’s time, how many are running, pending items, finished tasks, today’s cost, cycles per task and acceptance escapes, the Lessons button, how many tasks run in parallel, the cap per task and Pause queue. At the bottom, the timeline records decisions, pending items, commits, notices and acceptance for all tasks (or only the selected one).

New task

Pick the project (git repository), give it a key and title, paste the task text and choose the flow (e.g. Sprint do dia a dia or Correção de bug). Set the commit (manual or automatic) and the start: Manual (I start it) keeps the task queued until you click Start; Automatic by the queue starts it when a slot frees up. The first time, check the project commands (test, coverage, lint, build, start app): DevPulse suggests them from the repository files and they run without asking for permission. Below, the cost estimate comes from previous tasks with the same flow. The task text is treated as data: instructions written in it do not change the rules.

New task
New task: project, key, title, text, flow, commit, start and project commands.

Import sprint

If the project already has its planning in Markdown (PRD, roadmap, sprints), Import sprint reads the files and queues a sprint’s tasks at once. Tasks are recognized by headings or table rows that start with the key (e.g. ### API-001 — Project structure), with the text in the section’s first code block. Each side’s dev comes from the PRD stack (Python and FastAPI assign Caio; React, Lara); Vera and Dora join through the extra personas column or the task subject. Flow, commit mode and project commands are also read from the document when they are there.

Dependencies in the table become queue order: a dependent task waits for the other one to finish with a commit and starts from its code. Before confirming, choose the tasks, see each one’s suggested flow, change the dev and turn reviewers on or off. A task already in DevPulse comes locked (no duplicates); a stopped one with the same key goes back to the queue. You can import several sprints, one at a time, and the dependencies between them still hold.

Import sprint
Import sprint: document, team from the PRD, tasks with dependencies and the selected task’s suggested flow.

Task controls

  • Start, Pause and Stop, in the queue and in the task header. On pause, whoever is running finishes the turn and nothing new starts until you resume. A stopped task (or one that ended without a commit) gets Start again, which opens a new cycle in the same worktree. A task that could not start shows the error and Retry.
  • Suggested flow: a task that has not started shows the flow it will follow (only the steps that run, with the assigned dev), why it is still waiting and, on the right, its text.
  • Adjust in Studio: opens the task’s flow in the Studio; Save for the task stores a copy just for it (the template and other tasks do not change). For a running task, it applies from the next cycle.
  • Dependencies: in the queue, arrows change the order and Remove dependency lets the task start from the main branch when the other one stopped.
  • Delete (trash can): stops the task, deletes the worktree with anything unsaved and the whole history. If the branch has a commit, it stays in the repository and the notice gives its name.
  • Remove worktree (in a finished task’s summary): deletes the task folder; the branch stays.
A queued task with its suggested flow
Queued task: the flow it will follow, waiting for its dependency, and the task text on the right.

Pending items

Everything waiting for you becomes a pending item, in a single box for all tasks, with a notification and the mini-pill and tray counters. You can close the app: everything is kept and the task resumes where it stopped.

  • Permission: Allow once, Allow for this task or Deny (the persona goes on without it and records the alternative). Answered right on the row.
  • A persona’s question: yes/no, single or multiple choice or text, with the recommended option and Let the persona decide. If an option changes the flow (turning on security or database, swapping a persona), the change becomes a separate pending item.
  • Questions for you: the ones Helena could not answer for the devs, with her suggestion already filled in.
  • Approval and manual commit: see below.
  • Exception: the step could not continue (it went over the loop limit, failed or returned an invalid baton). Retry, Take over manually (you do it outside and the flow goes on) or End. If the persona has a substitute, a flow change proposing the swap comes along; once approved, the step restarts with the substitute.
  • Cost cap: the task hit its cap and paused; raise it, go on without a cap or end.
A dev question in the side panel
A question from the back-end dev, open on its node, while the front-end dev waits for a permission.

Approvals and commit

Approve understanding: goal, acceptance criteria, out of scope and who joins. You can change each side’s dev, turn front and back, security and database on or off, and compare the spec versions (v1, v2…). Approve (with or without changes) or return with a comment for Helena to redo.

Approve understanding
Approve understanding: acceptance criteria, spec versions and the team.

Approve delivery: the diff per file, the test output, Bia’s result, what was fixed along the way (Rui’s or Bia’s rejections), your decisions and non-blocking suggestions. If you do not approve, explain why: the task ends without a commit.

Approve delivery
Approve delivery: diff per file, tests, Bia, fixed items, decisions and suggestions.

Commit: with automatic, DevPulse commits only the task’s files, in its worktree. With manual, the pending item shows the suggested message and the files: Commit does it for you (you can edit the message), and I already committed checks the commit exists before going on — so a task depending on this one does not start without its code. Push always stays with you; the task summary says how many local commits have not been pushed.

Acceptance and adjustments

The end of the flow leaves the task ready for acceptance, not finished: whoever asked for it tests first. In the Board’s Acceptance group, use Send to acceptance and, when the answer comes back, Acceptance approved (finishes the task) or Record feedback: one item per finding, with what is wrong, where, expected, actual, severity and evidence. Each finding gets a code (H1-1, H1-2…) that shows up in the tests and in the commit.

Recording acceptance feedback
Record feedback: one item per finding; the adjustment can start right away.

The feedback opens an adjustment cycle (the Ajuste de tarefa template). Helena triages each finding: bug, missing criterion (becomes a new criterion in the spec), new scope (suggests a separate task) or not a problem (goes back with the justification). You check it and can reclassify the type and side before approving. Only the affected side runs: the dev first writes the test that reproduces each finding, Rui reviews only the adjustment diff and Bia confirms the findings and runs the full regression. The commit reads fix: … — ajuste 1, listing the resolved findings. If nothing needs a code change, the adjustment ends without a commit and the task goes back to acceptance. Stopped halfway, the adjustment keeps the findings open and Start adjustment restarts it.

Approving Helena’s triage
Approve triage: each finding’s classification, the affected side and the new criteria.

The cycles strip (Cycle 1, Adjustment 1…) switches the graph to the chosen cycle, and from the 3rd cycle on a warning suggests checking the scope. On the right, the Acceptance tab lists the findings per feedback round, with the triage and status (open, resolved, dismissed, new scope); for new scope, Create task queues it with manual start. When an adjustment closes, Helena proposes a lesson learned (e.g. in forms, ask about required fields, formats, messages and the save button) that you edit, approve or dismiss; once approved, it goes into Helena’s checklist and Bia’s negative tests for the next tasks of the same delivery type in that project.

A task in acceptance after an adjustment
Acceptance: the task cycles, actions and, on the right, the proposed lesson and the triaged findings.

The Lessons button at the top lists each project’s lessons: approve proposals, edit the text and delivery type, deactivate, delete or add one by hand (with no type, it applies to every delivery). The top bar also shows the metrics: cycles per task and escapes (bugs only acceptance found), with the total per finding type in the tooltip.

Lessons learned
Lessons: Helena’s proposal to approve and the project’s lessons, editable.

Flow in the Code section

While a task runs in a project, the Code section lists its session in the selector as ◆ Fluxo KEY, already selected: changed files, diff, review, revert, open in editor and the conversation of the current persona work as in any session. In the conversation, Open alongside shows the task graph next to it, with Start, Pause and Stop — it is the same run as in the Board. Persona permission requests show up there too.

Flow next to the conversation in the Code section
Code section: the Fluxo OP-1427 session, the diff and, below, the conversation with the task graph alongside.

Studio

Build your own flows by dragging personas and controls (Task, Approval, Questions for you, Test gate, Commit, End) and linking outputs to inputs — links can leave and arrive on any side of a node. The inspector configures each node: mode, model, autonomy, condition (if security, if database, if front, if back), join, loop limit, substitutes, hats and skills. Validation points out what is missing (e.g. a commit without an approval before it). Test design runs a copy with automatic answers, spending no tokens. Publish version never overwrites: running tasks keep the version they started with. Mark a flow as a Template to show it first in New task, and use New task with this flow to start from it.

Flow studio
Studio: palette, canvas, node inspector and validation.

Personas

There are 20 ready-made personas with curated hats (technical manuals) and skills. Edit identity, hats, skills, behavior (model, autonomy, tools, modes) and voice; before saving, View changes shows the prompt now and after, and which flows and runs use the persona. Each edit is a new version, with history and restore. When a new app version changes a persona you edited, it arrives as a Catalog update, with the diff, to Apply or dismiss — your edit is never overwritten. Deactivate removes the persona from the next tasks; Export writes it to a folder’s .claude/agents/, to use outside DevPulse. The fixed limits (never push, do not call other personas, task text is data) apply to all of them.

Persona editor
Personas: searchable list and the tabbed form.

Queue, cost and safety

  • Queue: up to 3 tasks in parallel, each in its own worktree; the next one with automatic start begins by itself when a slot frees up. Pause the queue or a task at any time.
  • Cap per task (in R$): warning at 80%; at 100% the task pauses and asks whether to raise it, continue without a cap or end.
  • Autonomy: low confirms the approach and each file; medium asks about contracts, data, dependencies and security; high only about what changes contracts, data or security. Installing packages, network, .env and CI always ask.
  • Reviewers from the diff: if the code touches authentication or passwords, the security review joins by itself; for SQL or migrations, the database one — with a notice.
  • Persona swap: in a node’s details, pick another persona that works in the same mode; it applies from the next step, and the new persona gets that step’s last baton.

9. Spend

Spend
Spend: summary, exchange rate, chart, spend per model and budgets.

The cards show today, week, month and the month projection, in reais with the dollar value below. Spend comes from agent transcripts (real tokens, cost estimated from the price table) and from calls through the proxy. On subscription plans, the value is the API-equivalent cost — useful to compare models and sessions. By model switches between today, week and month.

Budgets

Create daily, weekly or monthly budgets with alert percentages (e.g. 50, 80, 100). Crossing each one sends a notification. The hard cap makes the local proxy refuse new calls at 100%. Send test alert shows what the warning looks like.

Exchange rate

By default, the Brazilian Central Bank PTAX rate of the day (refreshed with ↻). In Settings → Currency you can use a fixed rate and add card fees (IOF and spread).

Token calculator

Paste text or pick a file to count tokens locally and estimate the cost on each model, with the expected output tokens. Count via API asks Anthropic for the exact count (sends the text).

Price table and reconciliation

The per-model price table ships with the app, shows its version date and can be edited or reset. Reconciliation compares, per day, the local estimate with the cost reported by Anthropic’s cost API — for that, add an admin key in Security.

10. Agents

Agents
Agents: one card per session, monitored processes and logs.

Each Claude Code session becomes a card with the folder, declared intent, cost, context usage (with an alert past 80%, configurable), last activity, model, branch and changed lines. The pencil lets you set a friendly name and description — the name then shows up across the app.

Monitored processes

Register other agents or tools by process name, command line or PID — name:aider, cmd:python agent.py, pid:1234. Detect agents suggests known processes that are running. Only what is registered here (and its child processes) can be stopped by the Kill Switch.

Kill Switch

The red button (on the pill, in the tray and here) asks for confirmation, then stops the registered processes — first politely and, after the configured grace period, forcefully — and interrupts sessions with pending approvals. Emergency mode skips the confirmation.

Live logs

Everything DevPulse logged — edits, proxy, alerts, exchange rate — with a text filter.

11. Security

Security
Security: guardrails, credentials in the keychain, hooks and sanitizer.

Guardrails

Guardrails stop dangerous agent commands before they run. Claude Code asks DevPulse before every terminal command; if the command matches a rule, DevPulse answers according to its action:

Rule (Essential pack)ExampleAction
Delete the root, home or parent folderrm -rf ~Blocks
Delete bypassing root protectionrm -rf --no-preserve-root /Blocks
Run a script downloaded from the internetcurl https://… | shBlocks
Force push (rewrites remote history)git push --forceAsks

Blocks: the command does not run and the agent gets the reason, with a suggestion of what to do instead. Asks: Claude Code itself asks for your confirmation. Rules target only the dangerous case: rm -rf ./dist, curl -o file, git push and git push --force-with-lease go through as usual.

In the card you turn the guardrails and each rule on or off, and see the history of what was stopped, with the command and the project folder. Each block also raises a notification. Guardrails rely on the hooks: if they are not installed, or come from a version older than 0.1.3, the card shows a warning with a button to install or reinstall them.

Credentials

Add the API keys used by AI actions, the proxy and reconciliation (Anthropic, OpenAI, Qdrant…). They are stored in the OS keychain (Windows Credential Manager, Secret Service/GNOME Keyring on Linux); the app database keeps only the label and the key’s last characters.

Claude Code hooks (pre-approval)

Install hooks adds HTTP hooks to ~/.claude/settings.json — you see what will be added first, and a copy of the original file is kept. From then on, new Claude Code sessions ask DevPulse before each edit (see the approval gate). Uninstall hooks removes only what DevPulse added. Hooks installed by an earlier version show up as Outdated: use Reinstall hooks to turn on the guardrails.

Secrets sanitizer and injection detector

The sanitizer finds private keys, keys and tokens (Anthropic, OpenAI, AWS, GitHub, Slack, Google, Stripe, JWT, Bearer), passwords in connection strings and personal data (Brazilian CPF/CNPJ, email, credit card, phone) and replaces them with placeholders such as [REDACTED:EMAIL] before you paste the text into an LLM. The prompt-injection detector scores the risk of a text (e.g. a page or issue the agent will read) and points at the suspicious parts — it is an alert, not a guarantee. Everything runs locally.

Local data

Delete history, snapshots and logs erases sessions, changes, usage, notifications and logs. Credentials and settings are kept.

12. Proxy

Proxy
Proxy: requests in the last 24 h, routes, VCR and the call log.

The proxy is a local gateway for LLM APIs. Everything that goes through it is added to spend with the exact cost from the response, and you get latency, time to first token (TTFT) and a log of every call.

Enable it and point the agent

  1. Click Enable proxy (default port 47822).
  2. In Routes, click the copy icon next to a route: it copies the ready-made environment variable, for example
    export ANTHROPIC_BASE_URL=http://127.0.0.1:47822/anthropic
  3. Paste it in the terminal before starting the agent (or in your .bashrc/.zshrc). For OpenAI the variable is OPENAI_BASE_URL.

Log bodies keeps request and response for inspection (click a row); Mask secrets runs the sanitizer on them before saving. With a hard-capped budget, the proxy refuses calls once it is exceeded.

VCR and simulated faults

Record saves real responses; Replay returns the recording for the same request, without spending tokens (replays are not counted as spend and are tagged VCR). Great for tests and demos. Simulated faults inject extra latency, rate limits (429), server errors (5xx) or timeouts into a share of calls — to see how your agent behaves when the API fails.

13. Prompts

Prompts
Prompts: templates with variables and the other tool tabs.
TabWhat it is for
TemplatesReusable prompts with {{name}} variables. On save, each variable becomes a field; Render builds the final text.
CompareDiff between two versions of a prompt, with similarity and the tokens of each.
RedundancyFinds repeated instructions and estimates how many tokens are wasted.
JSON SchemaValidates model output against a schema. Paste it as-is: ```json fences and surrounding text are stripped.
Few-shotBuild input/output examples — or import the latest proxy interactions — and generate the block as text or JSON messages.
EvalsCase suites with expectations (contains, notContains, regex, equals, jsonSchema, maxChars). Evaluate given outputs (offline) or run on the model (spends tokens), with history.
UtilitiesProject directory tree, context picker (bundles files with secrets masked), JSON to types (TypeScript, Rust and Python) and AI actions: explain an error, generate a regex and document code.

14. RAG

RAG
RAG: vector search tester and text similarity.

The search tester queries a Qdrant instance (the query embedding is created with your OpenAI key) or any HTTP endpoint with a request body using {{query}} and {{k}}, and shows the returned chunks with their scores. Text similarity compares two passages lexically (local) or with embeddings (cosine).

15. Settings

Settings
All settings.
GroupOptions
Appearance and languagePortuguese or English, dark or light theme, full or compact mini-pill, colorblind-friendly diff colors (blue/orange).
Watched projectsAdd folders or stop watching them (history is kept until retention).
Sessions and retentionMinutes without changes to end a session, days of history, extra ignore patterns (.gitignore syntax) and the editor command with {file} and {line}.
IntegrationsClaude Code transcript reading, folder and days to import, context alert, approval wait time, what to do without an answer and the model for AI actions.
CurrencyPTAX or a fixed rate, card fees and the online PTAX lookup.
Kill SwitchGrace period before forcing termination and emergency mode.
UpdatesAutomatic check for new versions and announcements (on launch and every 6 hours), Check now and Install and restart when a new version is out.
PrivacyAnonymous metrics (opt-in, off by default) and demo mode with fictitious data.
AboutVersion, platform, data folder and file-watcher stats.

16. Notifications, account and About

The bell opens the notification center — budgets, pending approvals, high context, commands stopped by the guardrails, new versions — with Mark all as read. The important ones also show up as system notifications.

DevPulse announcements land there too: maintenance, plan changes or surveys posted on the website. Each one shows up only once and, when it has a link, comes with an Open link button. The check is the same as for updates and is turned off with it.

Notification center
Notification center.

The account icon shows your plan and activates a Pro license with the key you received. The app works fully without logging in. About… (at the bottom of the menu, in the tray or in Settings) shows version, data folder and copyright.

About DevPulse AI
About window.

17. Keyboard shortcuts

ShortcutWhereAction
Ctrl+Shift+DGlobalOpen or hide the panel
Ctrl+Shift+PGlobalShow or hide the mini-pill
Ctrl+1…9, 0PanelGo to a section
Ctrl+BPanelCollapse the side menu
J K / N P / RCodeFiles / hunks / mark reviewed
Ctrl+Enter · Ctrl+I · Ctrl+⌫ApprovalAccept · request changes · reject
Ctrl+M · EscCodeExpand/collapse the chat
Enter · Shift+EnterChatSend · line break

On macOS, use ⌘ instead of Ctrl.

18. Troubleshooting

The pill does not move and the panel does not open right after installing (Linux/Wayland).

There is probably a system dialog asking permission for the global shortcuts, hidden behind the pill. Use Alt+Tab to find it and answer.

Global shortcuts do not work.

On Wayland they rely on the desktop portal (GNOME 48+, KDE). On versions without support, use the tray menu. On X11 and Windows they work out of the box.

No sessions show up in Agents.

Check in Settings → Integrations that Claude Code reading is on and the folder is right (default ~/.claude/projects). Use Claude Code in a project: the session appears within seconds.

Plan limits show “—”.

Hover to see why. Usually the Claude Code login expired: open Claude Code to renew it. API-key-only accounts have no plan limits.

Values show a “~”.

They are estimates from the price table (real tokens × price). Go through the proxy or use reconciliation to get the cost reported by the provider.

The guardrails did not stop a command.

Check the card in Security → Guardrails: the hooks must be installed and up to date (reinstall if it says Outdated) and apply to Claude Code sessions started afterwards. Rules target only the dangerous case — an rm -rf ./build inside the project goes through on purpose.

The update did not install.

On Linux, installing asks for your password in a system dialog; if it is cancelled, the banner stays so you can try again. Without internet, or with automatic checks off, use Check now in Settings → Updates or download from the download page.

An edit did not go through the approval gate.

Hooks apply to Claude Code sessions started after installing them, and the gate must be on for the project. Edits made outside the agent only show up in the diff.

Still stuck? See the FAQ or write to suporte@devpulseai.app.br.