The coordination protocol for autonomous systems.
File-based. Zero-token. Framework-agnostic. Bundled with EYDII.
Install · Quick Start · How It Works · The Greeting · SDK · Commands · Migration · Architecture
$ pulse
Welcome back, Hicham. Here's today's pulse:
Session: investor-prep chief_of_staff
Agents: 3 active 1 idle 0 quarantined
Tasks: 12 done 2 active 1 waiting on you
Cost: $4.23 / $50.00 8.5% of cap
Since you left:
✓ researcher completed "competitor landscape analysis"
✓ writer completed "executive summary draft"
⚠ critic flagged quality_degradation on writer (0.72)
Handled automatically:
• writer-backup quarantined (rate_limit) — recovered after 4m
• researcher hit OpenAI context limit — retried with chunked prompt
Waiting on you:
→ researcher needs: "Confirm priority list for deep dives"
[c] continue [n] new task [p] pause [d] dashboard
One word. Full situational awareness. Default on Enter is pause, not continue — safety first.
PULSE is a file-based coordination protocol for multi-agent systems. Agents and humans coordinate through the filesystem — YAML files in directories — instead of burning tokens through an LLM router.
No tokens consumed for coordination. Zero. The filesystem is the message bus. The daemon watches for changes and makes routing decisions. Every piece of state is a human-readable file you can cat, grep, or rsync to another machine.
PULSE is infrastructure, not an app. The reference category is Tailscale, Docker, and Ollama — not Notion or Figma. It ships as a CLI. The daemon is the product. The dashboard is the window onto what the product is doing.
PULSE ships with EYDII embedded — content-blind behavioral intelligence that watches what your agents do without ever seeing what they say. You can turn it off. But you probably won't want to.
Every multi-agent orchestration framework solves coordination the same way: route messages through an LLM. Every message costs tokens. Every token costs money. A 5-agent team discussing task assignment can burn hundreds of thousands of tokens per day on coordination alone — before any real work happens.
PULSE takes a fundamentally different approach:
| Token-routed frameworks | PULSE | |
|---|---|---|
| Coordination cost | Tokens per message (LLM-routed) | Zero tokens (file-based) |
| Framework support | Limited, vendor-locked | 13+ frameworks, protocol-agnostic |
| Trust model | Promise-based (can see content) | Architectural (cannot see content) |
| Audit trail | Application logs | Filesystem — every message, transition, heartbeat is a file |
| Drift detection | None | Peer reporting + 8-indicator health scoring |
| Human-in-the-loop | External to the system | First-class agent with own state and SLA |
| Failure communication | Raw error codes | Natural-language translation with provider-specific guidance |
| Migration | Vendor-specific export | rsync your session directory |
| Session templates | None | Save and reuse team configurations |
| SLA enforcement | None | Human response SLA with breach detection |
One command. Open your terminal and paste:
Mac / Linux:
curl -fsSL pulse.veritera.ai | shWindows — open PowerShell and paste:
irm pulse.veritera.ai/install.ps1 | iexThat's it. The installer handles everything — downloads what's needed, installs PULSE, and launches it. You'll answer four quick multiple-choice questions to set up your team, and you're running.
From then on, every time you open a terminal, just type:
pulseAlready have Node.js 18+?
npm install -g @veritera.ai/pulsepulseThat's it. One word. PULSE walks you through setup on first run — four multiple-choice questions, under 60 seconds:
- How do you want to work with your agents? — Chief of staff, captain, or on the field
- What kind of project is this? — Investor deliverable, software build, research, marketing, or custom
- Which AI should power your agents? — All Claude, All GPT, or mix per agent
- Should PULSE run all the time or while you're working?
Everything else has intelligent defaults that self-tune through use. The daemon starts automatically.
The greeting is the product's personality. When you type pulse with no arguments, you get full situational awareness in a single screen:
- Triage — what's done, what's paused, what's waiting on you
- Since you left — natural-language summary of what happened while you were away
- Waiting on you — items that are blocked until you act
- Four single-keystroke options —
[c]continue,[n]new task,[p]pause,[d]dashboard
The default action on Enter is pause — not continue. This is a deliberate safety asymmetry. Resuming work is a conscious decision. The system never runs away from you.
Every PULSE session is a directory on disk. Everything is a file:
my-project/
├── pulse.yaml ← session config (topology, routing, cost cap)
├── registry/ ← agent + human registrations
├── tasks/ ← task board (queued → claimed → in_progress → done)
├── state/ ← agent lifecycle states
├── heartbeats/ ← liveness signals
├── peer-reports/ ← drift detection (cross-agent, never self-report)
├── agents/{id}/ ← per-agent working directory
│ ├── working-doctrine.md ← accumulated knowledge
│ ├── decision-log.md ← decisions + reasoning
│ ├── open-questions.md ← questions for humans/peers
│ └── state-of-work.md ← current progress
├── messages/ ← inter-agent messaging
├── cost/ ← per-agent, per-task cost tracking
├── doctrine/ ← session-level guidelines
├── artifacts/ ← shared outputs
└── .pulse/
├── pulse.sock ← daemon IPC
├── digest.json ← pre-computed session summary
└── observer-queue/ ← EYDII telemetry (content-blind)
Every file is human-readable YAML or Markdown. No databases. No binary formats. No hidden state. Migration to another machine is rsync — because the directory is the complete state of your agent organization.
The PULSE daemon watches the session directory for changes and enforces the protocol:
- Detects new agent registrations and validates them
- Routes tasks to the best agent using 8-dimension scoring
- Monitors heartbeats and quarantines unresponsive agents
- Aggregates peer drift reports and triggers transitions when thresholds are crossed
- Tracks cost per agent and per task, enforcing session cost caps
- Produces the session digest that powers the greeting
- Triggers EYDII observation (content-blind — never reads agent work)
Every raw signal — error codes, health scores, state transitions, routing decisions — is translated at render time into natural language the founder can act on. Every message answers four questions:
- What happened
- Whose responsibility it is (or is not)
- What the system did about it
- Where to look for more
You should never need to become a debugger for infrastructure you didn't build.
File names shape how agents think about coordination. Schema fields shape how they report progress. State identifiers shape how the system reasons about participants.
There is no duration_days field in the task schema — agents can't report in human time. There are no content fields in the telemetry schema — EYDII can't see content. The architecture makes wrong behavior structurally impossible, not just discouraged.
You're not watching from outside. You're a node in the coordination graph with your own capabilities, SLA, and state:
| State | Meaning |
|---|---|
PRESENT |
Available — monitoring the session |
FOCUSED |
Deep work — only interrupt for critical items |
AWAY |
Away — agents operate autonomously |
ON_DECK |
Back soon — queue non-urgent items |
Never "quarantined." Never "offline." The vocabulary is different because the relationship is different. If you're a bottleneck, PULSE says so — honestly and respectfully.
pulse human focused # Deep work mode
pulse human away # Stepping out
pulse human present # Back and availableDrift detection is peer-based. Agents observe each other and file reports. The daemon aggregates reports using recency-weighted scoring. Three critical reports — or a composite score above 0.7 — triggers automatic transition to DRIFTING.
This is a deliberate architectural choice. Self-reporting is unreliable because a drifting agent doesn't know it's drifting. The same neural degradation that causes drift impairs the ability to detect it. Peer observation solves this.
Six drift signal types: quality_degradation, response_latency, instruction_deviation, repetition, coherence_loss, capability_mismatch.
When an agent drifts and gets replaced, four files transfer automatically:
| Artifact | Purpose |
|---|---|
working-doctrine.md |
Accumulated knowledge and guidelines |
decision-log.md |
Decisions made with reasoning |
open-questions.md |
Unresolved questions for humans/peers |
state-of-work.md |
Current progress and next steps |
The replacement agent's entire onboarding is: "read these four files, then continue." Target: under 90 seconds, seamless. No context lost. No work repeated.
EYDII runs as a separate process with OS-level filesystem permissions restricted to four observation surfaces: state transitions, heartbeats, task metadata, and peer reports. It cannot read agent working directories, messages, or artifacts. This is enforced at the operating system level, not by policy.
The telemetry it generates contains hashed IDs and behavioral patterns only — never prompts, outputs, or agent reasoning. This is the compound moat: the architecture makes privacy violation structurally impossible.
# Verify EYDII can't read your content (canary check)
pulse status # Shows EYDII permission status
# Turn it off if you want (but you probably won't)
pulse config set eydii offEvery task assignment is an 8-dimension scoring decision:
| Dimension | What It Measures |
|---|---|
| Capability | Does this agent have the skill for this task? |
| Load | How many tasks is the agent already working on? |
| Track Record | Historical success rate for similar work |
| Cost | Cost tier of the agent's framework |
| Latency | Expected response time |
| Dependencies | Are prerequisite tasks complete? |
| Affinity | Has this agent done similar work before? |
| Drift Awareness | Is the agent showing signs of drift? |
Four strategies shift the weights with a single word:
pulse mode balanced # Default — weighs all dimensions
pulse mode cost_optimized # Minimize spend
pulse mode latency_optimized # Minimize time-to-completion
pulse mode quality_optimized # Maximize capability + track recordEvery routing decision includes a natural-language narration explaining why the agent was selected.
When an agent fails, it isn't broken — it's quarantined. Six sub-reasons, each with a different recovery path:
| Reason | What Happened | Recovery |
|---|---|---|
rate_limit |
API rate limit hit | Auto-retry with backoff |
provider_outage |
API endpoint down | Wait for recovery signal |
billing_failure |
Payment issue upstream | Founder intervention |
auth_failure |
Credentials expired/invalid | Founder intervention |
cost_cap |
Session cost cap reached | Founder approval to continue |
unknown |
Unclassified failure | Founder triage |
Tasks redistribute automatically to non-quarantined agents. When a quarantined agent recovers, it returns to ACTIVE and picks up new work — no manual intervention required for auto-recoverable failures.
Every quarantine event surfaces a human-readable explanation with a specific recovery action — not a raw error code. PULSE maintains a provider-specific error catalog covering Anthropic, OpenAI, Google, and generic network failures, each with confidence tiers (high/medium/low) so you know how reliable the diagnosis is.
Agents with a configured fallback_provider can absorb transient failures automatically. If the primary provider is rate-limited, the fallback handles the next task — no founder intervention required for transient issues.
IDLE → ACTIVE → DRIFTING → TRANSITIONING → REPLACED → ARCHIVED
│ │ │
└───────┴─────────┴── QUARANTINED → ACTIVE (recovery)
→ ARCHIVED (retirement)
Every state transition is recorded as a file. Every transition is reversible where it makes sense. The lifecycle is a state machine with validated transitions — invalid transitions are rejected, not silently ignored.
pulse costSession Cost Summary
Total: $4.23 / $50.00 (8.5%)
─────────────────────────────
researcher $2.10 (49.6%)
writer $1.85 (43.7%)
critic $0.28 (6.6%)
Alerts: soft at 75% │ warn at 90% │ pause at 100%
Three alert thresholds. Per-agent and per-task attribution. The daemon enforces the session cost cap — when you hit 100%, agents pause. No runaway costs.
Build agents that participate in PULSE sessions:
import { PulseAgent } from "@pulse/sdk";
const agent = new PulseAgent({
sessionDir: "./my-project",
agentId: "researcher",
name: "Researcher",
framework: "claude-code",
role: "researcher",
capabilities: { research: 0.95, analysis: 0.8 },
});
// Register and start heartbeat
agent.register();
agent.startHeartbeatLoop();
// Claim and work on tasks
agent.claimTask("task-123");
agent.startTask("task-123");
// ... do the actual work ...
agent.completeTask("task-123");
// Report drift on a peer (never self-report)
agent.reportPeer("writer", {
signal_type: "quality_degradation",
severity: 0.6,
evidence: "Response quality dropped in last 3 outputs",
});
// Update the four handoff artifacts
agent.updateWorkingDoctrine("## Key findings\n...");
agent.updateDecisionLog("Chose depth-first approach because...");
agent.updateOpenQuestions("- What's the priority for the Asia analysis?\n");
agent.updateStateOfWork({
task_id: "task-123",
status: "in_progress",
progress_summary: "Completed 8 of 12 competitor profiles",
next_steps: ["Finish remaining 4", "Draft executive summary"],
updated_at: new Date().toISOString(),
});
// Send messages to other agents
agent.sendMessage("writer", "Research complete — analysis ready for synthesis");The SDK is file-based. Every operation writes a YAML or Markdown file. No network calls. No daemon dependency for writes. The daemon watches the files and reacts.
PULSE notifies you through Telegram when things need your attention:
pulse telegram setup # Configure bot token + chat ID
pulse telegram start # Start the notification bridge
pulse telegram test # Send a test message
pulse telegram stop # Stop notificationsWhat it sends:
- Task completions and failures
- Drift alerts when agents need replacement
- Quarantine events requiring your intervention
- Periodic session digests
- Items waiting on you
What you can send back:
/status— get current session status/agents— list agents and their states/tasks— list active tasks/human away— set your availability/human present— you're back
| Command | Description |
|---|---|
pulse |
The greeting — full situational awareness |
pulse init <name> |
Create a new session (3 questions, 60 seconds) |
pulse daemon start|stop|status |
Manage the coordination daemon |
pulse agent add|remove|list |
Register and manage agents |
pulse task add|assign|list|done |
Create and manage tasks |
pulse cost |
Cost summary (per-agent, per-task) |
pulse mode [strategy] |
View or set routing strategy |
pulse handoff <from> <to> |
Transfer agent responsibilities |
pulse human [state] |
Set human availability (PRESENT/FOCUSED/AWAY/ON_DECK) |
pulse drift sweep |
Run drift assessment across all agents |
pulse drift <agent-id> |
Check drift status for one agent |
pulse report <agent-id> |
File a drift report (human as peer observer) |
pulse log [agent|daemon] |
View agent or daemon logs |
pulse config |
View session configuration |
pulse config set <key> <value> |
Update session configuration |
pulse dashboard |
Terminal dashboard |
pulse dashboard --watch |
Live-updating terminal dashboard |
pulse export json|snapshot|archive |
Export session data |
pulse import <archive> |
Import session from archive or snapshot |
pulse template save|list|delete |
Save and reuse session templates |
pulse telegram setup|start|stop|test |
Telegram notification bridge |
pulse upgrade |
View current tier and upgrade options |
pulse agent debug <id> |
Full diagnostic for a specific agent |
pulse daemon pause|resume |
Pause/resume for migration |
| Package | What It Does |
|---|---|
@pulse/protocol |
The contract — types, Zod schemas, state machines, paths, constants |
@pulse/core |
Shared infrastructure — atomic I/O, IPC over Unix socket, logger, clock |
@pulse/daemon |
The brain — session manager, lifecycle engine, drift detector, heartbeat monitor, 8-dimension routing engine, task engine, cost engine, digest builder, filesystem watcher |
@pulse/cli |
The face — 22 commands, three-question onboarding, the canonical greeting |
@pulse/sdk |
Agent integration — file-based, zero-dependency agent SDK |
@pulse/observer |
EYDII sidecar — content-blind behavioral observer with OS-level permission enforcement |
@pulse/emitter |
Telemetry transport — batched, compressed, HTTPS |
@pulse/telegram |
Notification bridge — bidirectional Telegram bot |
- File-based state — the session directory is the single source of truth. No databases. No hidden state. Migration is
rsync. - Atomic writes — every file write goes through write-to-temp-then-rename. No partial reads. No corruption from concurrent access.
- Unix socket IPC — the daemon and CLI communicate over a local Unix socket. No HTTP. No network.
- Content-blind by construction — EYDII's filesystem permissions are set at the OS level. It can read state, heartbeats, task metadata, and peer reports. It cannot read agent directories, messages, or artifacts. This isn't a policy — it's a permission.
- Protocol-level vocabulary shaping — if a field doesn't exist in the schema, agents can't report it. The architecture makes wrong behavior structurally impossible.
Claude Code, Claude Cowork, OpenAI, ChatGPT, Cursor, LangChain, LangGraph, CrewAI, n8n, Agno, Mastra, Google ADK, Ollama, LM Studio, Open WebUI, and custom.
PULSE is protocol-agnostic. Any agent that can read and write files can participate. The SDK makes it easier, but it's not required.
| Tier | Frameworks | Price |
|---|---|---|
| Free | Up to 5 | Free forever |
| Pro | Up to 10 | $99/year |
| Enterprise | Unlimited | Contact us |
The free tier is not a trial. It is a complete, fully functional product with full EYDII protection. No time limits. No feature gates. No nag screens.
The paywall appears at exactly one moment: when you try to connect a 6th framework. It's a single CLI prompt into Stripe. Under 30 seconds.
pulse upgrade pro # $99/year via Stripe
pulse upgrade status # Check current tierBecause PULSE is file-based, migration is copying a directory. Target: 5-15 minutes, any machine to any machine.
# 1. Pause (flush state, finish in-flight work)
pulse daemon pause
# 2. Copy the session
rsync -az ./my-project/ user@newmachine:~/my-project/
# 3. On the target machine
pulse daemon start
pulse # The greeting should be identicalOr use the built-in archive:
pulse export archive my-project.tar.gz
# Transfer the file to another machine
pulse import my-project.tar.gzSession templates let you reuse team configurations across projects:
# Save your current setup as a template
pulse template save investor-team
# Start a new project from the template
pulse init new-pitch --from-template investor-teamLaptop to home server. Home server to VPS. VPS to another VPS. The session directory is the complete state. The only thing that doesn't transfer is your API keys (environment variables) — and that's a security feature, not a limitation.
git clone https://github.com/veritera-ai/pulse.git
cd pulse
npm install
npm run build # Builds all 8 packages
npm test # 70 tests across 6 suitespulse/
├── packages/
│ ├── protocol/ ← types, schemas, state machines
│ ├── core/ ← shared utilities (I/O, IPC, clock)
│ ├── daemon/ ← session manager, lifecycle, routing
│ ├── cli/ ← commands, onboarding, greeting
│ ├── sdk/ ← agent integration SDK
│ ├── observer/ ← EYDII content-blind sidecar
│ ├── emitter/ ← telemetry transport
│ └── telegram/ ← notification bridge
├── tests/
│ ├── unit/ ← protocol, scoring, SDK tests
│ └── integration/ ← full lifecycle tests
└── .github/
└── workflows/ ← CI
- Not an LLM router. PULSE does not route messages through a language model. Coordination is file-based. Zero tokens.
- Not a chatbot framework. PULSE coordinates work, not conversations.
- Not a hosted service. PULSE runs on your machine. Your data stays on your machine. Veritera does not host the daemon.
- Not open source. PULSE is free to use but closed-source. Source code is not published.
- Not a replacement for your agent framework. PULSE sits alongside Claude, OpenAI, LangChain, CrewAI, etc. It coordinates them. It doesn't replace them.
Veritera Corporation
veritera.ai ·
pulse@veritera.ai