Eve - Managed OpenClaw for Software Business Ops

TL;DR

TL;DR: Eve is a managed, hosted OpenClaw that runs the operational side of a software business — support tickets, failed payments, churn signals, release notes, weekly reporting — by connecting to 3,000+ services (Stripe, GitHub, Linear, Sentry, PostHog, Slack, Discord, Notion, Figma, HubSpot, Gmail) and acting through Claude Opus 4.6 with persistent memory, parallel sub-agents, and an iMessage-first interface.

Source and Accuracy Notes

• Official site: eve.new
• Show HN launch: item?id=47721255 (72 points, 40 comments)
• Author: Adam (single founder, currently ships alone)
• Pricing verified from the live pricing page: Free, $40/mo Starter, $200/mo Pro, $1,000/mo Max
• All architecture details come from the launch post and the public landing page

What Is Eve?

Eve is positioned as “managed OpenClaw for work.” The framing matters: OpenClaw is the open-source framework that gives AI agents a real Linux sandbox, a real filesystem, headless Chromium, code execution, and tool integrations. Eve wraps that framework in a hosted product so you do not have to self-host anything, wire up model routing, or babysit sub-agent orchestration.

The pitch on the landing page is direct: “You build the product. Eve runs the rest.” The use cases it ships with are deliberately operator-flavored, not personal-assistant-flavored:

• Triage overnight support tickets, answer the common ones, file bugs for the rest
• Detect a payment failure on Stripe, retry it, email the customer a backup link, flag in Slack if it fails again
• Watch Datadog for a slow endpoint, find the N+1 query, and open a PR that combines the queries
• Draft release notes for the v2.4 you just shipped and post to Discord
• Spot nine accounts with usage down 60% month-over-month, draft win-back emails for seven, flag the two biggest for a human

The shift from “AI helper that suggests things” to “AI coworker that ships things in your stack, then shows you the diff to approve” is the entire product story.

How Eve’s Architecture Differs From a Chatbot

The launch post calls out the pieces that matter:

Sandbox:        2 vCPUs, 4GB RAM, 10GB disk per session
Code execution: real filesystem, headless Chromium
Orchestrator:   Claude Opus 4.6 routes to domain models
Sub-agents:     parallel, coordinate through shared filesystem
Memory:         persistent across sessions (compounds over time)
Connectors:     3,000+ services (Stripe, GitHub, Linear, Sentry, ...)
Interface:      web app + iMessage + Slack + email

The interesting choices are the orchestrator and the memory model. Eve does not run a single Claude conversation end-to-end. Claude Opus 4.6 acts as the orchestrator and dispatches subtasks to smaller, domain-specific models — one for browsing, one for coding, one for research, one for media generation. For complex work, Eve spins up parallel sub-agents that coordinate through the shared filesystem in the sandbox rather than by passing messages back through the orchestrator. That keeps the orchestrator’s context window free for routing decisions instead of being filled with intermediate work.

The second choice is the persistent memory. Eve remembers context across sessions, so the tenth interaction with Eve in a week does not start from zero — it knows the stack you have, the channels you prefer, the customers you flagged, and the PRs that are still open. The launch post is explicit: “context compounds over time.”

Setup Workflow

Step 1: Sign up and claim the $100 launch credit

The launch post says: “I’ve given every new user $100 worth of credits to try it.” That covers serious experimentation on the Free tier before you need to upgrade.

# Open the signup page
open https://eve.new/login

Account creation is the standard email plus OAuth flow. No credit card is required for the Free tier.

Step 2: Connect your stack

Eve’s “Connect your stack” step is where most of the value unlocks. The web app shows a connector gallery; the ones most software teams reach for first are:

• Payments: Stripe
• Code: GitHub, GitLab
• Issues: Linear, Jira
• Observability: Sentry, Datadog, PostHog
• Infra: Supabase, Vercel
• Comms: Slack, Discord, iMessage, Gmail
• Knowledge: Notion
• Design: Figma
• CRM: HubSpot, Intercom

Each connector uses OAuth. Eve does not see the raw tokens directly — it uses the Composio connector layer under the hood (the page preloads connector logos from logos.composio.dev).

Step 3: Pick a workflow to delegate

The fastest way to get value is to give Eve one recurring, time-consuming task and watch it run. Three common first tasks:

Triage support tickets overnight. Eve reads your help desk, classifies tickets, drafts replies for the common ones, files Linear bugs for the engineering questions, and flags the VIP account issues for you. You wake up to a triage report instead of a 30-ticket inbox.

Watch your billing for failures. Eve polls Stripe for failed charges, retries them, sends the customer a backup payment link, and posts a Slack alert if the retry also fails. The example in the launch post is exactly this pattern.

Draft release notes after a ship. Point Eve at the GitHub repo, tell it which version you just cut, and it produces a changelog grouped by theme, with the PRs that went into each section. You approve the draft and Eve can post it to Discord, send the customer email, or write the changelog file in the repo.

Step 4: Talk to Eve from anywhere

Eve’s interface is three surfaces:

# Web app — primary surface, shows real-time work
open https://eve.new

# iMessage — fire-and-forget tasks from your phone
# (text the Eve number; reply when the work is done)

# Slack and email — forward threads, ping the bot, get replies in-channel

The iMessage integration is the unusual one. It is built for the “I’m walking out the door, here’s the task” pattern: you text Eve the work, put your phone down, and get a notification when it is done. This is the same mode the launch post demos with the tax returns and the demo video editing.

Step 5: Review and approve

Eve does not silently take destructive actions. Every change ships as a draft with sources attached — a PR link, a customer record, a Linear ticket. You can edit the draft, approve it, or send Eve back to try again. The PR pattern is the most concrete: Eve opens a PR on the repo, you review the diff the way you would review any other PR, and merge when ready.

Pricing Tiers

Eve’s pricing is credit-based. All tiers share the same integration catalog and core capabilities; the difference is throughput.

| Tier | Price | Credits | Daily Refresh | Cloud Storage | |---|---|---|---|---| | Free | $0 | — | 300 | — | | Starter | $40/mo | 4,000 | 300 | — | | Pro | $200/mo | 20,000 | 300 | yes | | Max | $1,000/mo | 100,000 | 300 | yes |

The “300 daily refresh credits” line is consistent across all paid tiers — that is the baseline you can count on every day regardless of plan. The main credit pool (4k / 20k / 100k) covers heavier workloads like processing a backlog of tickets or running a multi-step refactor across many files.

Deeper Analysis

What Eve gets right

The interface choice. Picking iMessage as a first-class surface is a strong bet. Most “AI coworker” products stop at a web app and ask you to come to them. Eve goes to where the request originates — a text from your phone, a Slack mention, an email forwarded with one word of context. That changes the latency-to-task ratio for busy operators.

The approval model. Every action lands as a draft with sources. PRs are PRs you can diff. Emails are drafts you can edit. Stripe retries are visible in the activity log. The product is opinionated that humans stay in the loop on anything that touches customers, code, or money — which is the right default for a tool that acts on your behalf.

The orchestrator pattern. Routing different subtasks to different domain models keeps costs and latency reasonable. A research subtask that needs web browsing does not need Opus. A code edit that touches a single function does not need to keep Opus in the loop. The orchestrator model is what makes the credit-based pricing workable.

What to watch for

Single-founder risk. The launch post is signed by “Adam” alone. The product is ambitious, the integrations list is long, and there is no team page yet. A solo founder shipping a hosted agent harness that touches production systems for paying customers is a real operational risk if Adam disappears for a week. Watch for team growth or a YC announcement as a sign of durability.

Pricing cliffs. $40 / $200 / $1,000 is a wide range with no in-between tier. A team that outgrows the 4,000 credits on Starter has to jump to Pro at five times the price. The credit usage is also not transparent in the landing page (no per-task credit cost table), so you may not know whether you need Pro until you have already burned through Starter.

The 3,000+ claim. “3,000+ integrations” includes the entire Composio connector catalog. The depth of each integration varies: Stripe, GitHub, Linear, Sentry, Slack, and Notion are clearly first-class (real bidirectional sync, PRs, ticket creation). Niche connectors may be one-way or read-only. Verify the specific integration you depend on before committing to a paid plan.

Practical Evaluation Checklist

Before you put Eve on a real workflow, run it through these checks:

• [ ] Connect Stripe and ask it to summarize this week’s MRR
• [ ] Connect GitHub and ask it to draft release notes for your last release
• [ ] Connect Sentry and ask it to triage the last 24 hours of errors
• [ ] Send it a task from iMessage and confirm the reply round-trip
• [ ] Open one PR it produces and review the diff like a human PR
• [ ] Watch the activity log for a long task and confirm sources are cited
• [ ] Run a credit-cost estimate on your heaviest recurring task and pick the right tier

Security Notes

Eve runs your connected-account credentials through the Composio connector layer, not through your own OAuth apps. That means:

• Token storage: Composio-managed, encrypted in transit and at rest per the FAQ
• Sandbox isolation: Each session runs in a 2 vCPU / 4GB / 10GB Linux sandbox; sessions are isolated per task
• Destructive actions: Require approval (Eve drafts, you sign off) by default
• Customer data: Eve has read access to your Stripe customers, Linear tickets, Notion docs, and help desk — make sure your team knows that before you connect a customer’s PII
• Compliance: The footer mentions Terms, Privacy, and Compliance pages (Adam AI Labs, Inc.)

The reasonable default is: connect read-heavy integrations (GitHub, Linear, Sentry, PostHog) freely, gate write integrations (Stripe, customer email, production deploys) behind team approval until you trust the output.

FAQ

Q: Is Eve the same as OpenClaw? A: No. Eve is a hosted product that runs on top of the OpenClaw framework. You get the same sandbox, filesystem, and tool-calling model, but Eve handles the model routing, memory persistence, connector wiring, and the web/iMessage/Slack/email interface. If you want to self-host, use OpenClaw directly. If you want a managed version that you can text from your phone, Eve is that.

Q: Do I need a credit card to try it? A: No. The Free tier does not require a card and starts you with $100 in launch credit, which is enough to run a few serious workflows before deciding whether to upgrade.

Q: How is Eve different from a chatbot that calls APIs? A: Three things: a real Linux sandbox per session (not just a chat thread), a Claude Opus 4.6 orchestrator that dispatches to domain-specific models for subtasks, and persistent memory that compounds across sessions. A chatbot suggests; Eve drafts the PR, opens the ticket, retries the charge, and shows you the diff to approve.

Q: Does it work with self-hosted tools like a private Sentry or self-hosted GitLab? A: The connector list on the landing page is built around Composio’s hosted catalog, which covers SaaS services. For self-hosted instances, you would need to confirm the connector supports a custom URL and credential, which is not a documented first-class use case yet.

Q: Can I see what Eve is doing in real time? A: Yes. The web app shows a live activity feed of agents spawning, files being written, CLI commands being run, and connectors being called. This is the primary surface for the “watch work happen” pattern the launch post emphasizes.

Q: What happens to my data if I cancel? A: The pricing page does not spell out retention windows. The reasonable assumption is that connected-account tokens are revoked and task history follows the standard account-deletion flow, but you should confirm in writing before relying on Eve for any data you cannot regenerate.

Conclusion

Eve is a well-scoped product with a clear thesis: the operational side of a software business is repetitive, tool-heavy, and time-consuming, and an agent harness with a real sandbox, real integrations, and real approval flow can take most of it off your plate. The 3,000+ integrations list is ambitious, the iMessage interface is unusually well-considered, and the credit-based pricing maps cleanly onto usage.

The risks are real but standard for a solo-founder launch: durability of the team, transparency of the per-task credit cost, and depth of niche connectors. None of these disqualify the product, and the $100 launch credit is enough runway to find out whether Eve fits your stack before you pay anything.

For teams that are already paying for Zapier, an ops generalist, or a junior engineer’s time on triage and reporting, Eve is worth a weekend. Connect Stripe, GitHub, Linear, and Sentry, run the four evaluation checklist tasks above, and decide based on what the drafts actually look like.