Meet your agents

Specialized AI workers that handle entire workflows end-to-end. Each agent has skills, persistent memory, and gets better with every task.

Coding Agent

Ship features while you sleep

A full-stack development agent that reads your codebase, writes code, runs tests, and opens PRs. Understands architecture patterns from persistent memory and improves with every task.

Code generationRefactoringUnit testingPR creationCode review

End-to-end flow

1
Create task
"Add dark mode toggle to the settings page" — from web UI, Slack, or Telegram
2
Coordinator routes
Jarvis (coordinator) analyzes the task and routes it to the coding agent based on skill match and availability
3
Context loading
Agent reads codebase structure, relevant files, and past architecture decisions from persistent memory and Obsidian notes
4
Implementation
Agent writes the component, adds theme context, updates CSS variables, and creates a toggle in Settings — across multiple files
5
Quality gates
Auto-runs: TypeScript type check → unit tests → ESLint → build. If any gate fails, Auto-Iterate retries with gate output as feedback (up to 3x)
6
Review
Task moves to In Review. You get a Slack/Telegram notification with a diff summary. Approve, request changes, or "Implement Fixes" with custom instructions
7
Memory update
Agent writes learnings to code domain memory: "project uses CSS variables for theming, toggle in Settings/Appearance"
8
Done
Task marked complete. PR ready to merge. Next theming task will recall this pattern automatically
agent-log.txt
// Task: "Add dark mode toggle to settings"
// Agent reads: src/components/Settings.tsx, src/styles/globals.css
// Agent writes:

// src/context/ThemeContext.tsx — new file
// src/components/ThemeToggle.tsx — new component
// src/components/Settings.tsx — adds toggle to appearance section
// src/styles/globals.css — adds :root / .dark CSS variables
// src/tests/ThemeToggle.test.tsx — unit tests

// Quality gates: ✓ tsc ✓ jest (4/4) ✓ eslint ✓ build
// → In Review → Approved → Done
Marketing Agent

Campaigns that write themselves

Plans and executes multi-channel campaigns: competitor analysis, blog posts, social threads, email sequences. Coordinates with Research and Social agents for full-funnel output.

Campaign planningBlog writingSEO optimizationEmail sequencesSocial threads

End-to-end flow

1
Create task
"Run Q3 product launch campaign — competitor analysis, announcement blog, Twitter thread, email sequence"
2
Coordinator splits
Coordinator breaks into 4 subtasks and assigns: researcher → competitive intel, marketer → blog + email, social → Twitter thread
3
Research phase
Research agent crawls competitor sites, scrapes release notes, writes findings to Research/Competitor-Q3-Analysis.md in Obsidian
4
Content creation
Marketing agent reads brand playbook from memory, competitor findings from Obsidian, and drafts an SEO-optimized blog post and 5-email drip sequence
5
Social repurposing
Social agent takes the blog post, extracts key points, and creates a 7-tweet thread with hooks and CTAs
6
Review cycle
All 3 subtasks arrive in Review. You approve the research, request tone changes on the blog ("more conversational"), approve the thread
7
Implement fixes
Marketing agent re-drafts the blog with your feedback. New version arrives in 2 minutes. Approved
8
Done
Campaign assets complete. Obsidian updated: Marketing/Campaigns/Q3-Launch.md with links to all deliverables. Next campaign reuses the playbook
agent-log.txt
// Task: "Q3 product launch campaign"
// Subtasks created by coordinator:

// 1. Research → Competitor Analysis
//    Output: Research/Competitor-Q3-Analysis.md
//    Status: ✓ Done

// 2. Marketing → Blog Post + Email Sequence
//    Output: blog-q3-launch.md (2,400 words, SEO score 94)
//           email-sequence-q3.md (5 emails, 3-day cadence)
//    Status: ✓ Done (after 1 revision)

// 3. Social → Twitter Thread
//    Output: thread-q3-launch.md (7 tweets, 3 images)
//    Status: ✓ Done

// Memory: brand voice patterns, Q3 messaging framework
// Obsidian: Marketing/Campaigns/Q3-Launch.md ← linked
Support Agent

Resolve tickets before coffee

Handles customer tickets with context-aware responses. Reads customer history, past resolutions, and knowledge base articles. Drafts replies for human approval or sends autonomously.

Ticket triageResponse draftingKnowledge baseEscalation routingCustomer history

End-to-end flow

1
Ticket arrives
"Customer reports checkout fails after applying discount code" — via HubSpot sync, Slack, or manual task creation
2
Context retrieval
Agent reads: customer's past 5 tickets, Support/Checkout-Issues.md from Obsidian, discount code known issues from memory
3
Pattern matching
Memory recalls: "discount code bug with codes >20 chars fixed in v2.3.1 — check if customer is on latest version"
4
Response draft
Agent drafts a personalized reply: acknowledges the issue, asks for discount code length, suggests updating to latest version, includes workaround steps
5
Human approval
Draft appears in Review with customer context sidebar. You approve as-is or edit the tone before sending
6
Send & monitor
Response sent via the customer's channel. Agent sets a 24-hour follow-up reminder
7
Resolution
Customer confirms the update fixed it. Agent marks resolved, updates Support/Checkout-Issues.md with new data point
8
Learning
Memory updated: "discount code checkout failure — 90% resolution rate with version update suggestion". Future similar tickets auto-suggest this solution
agent-log.txt
// Ticket: "Checkout fails with discount code SUMMER2025MEGA"
// Agent reads:
//   - Customer history: 3 prior tickets, enterprise plan
//   - Obsidian: Support/Checkout-Issues.md
//   - Memory: "codes >20 chars → known v2.3.0 bug"

// Draft response:
// "Hi Sarah, thanks for reaching out. This looks related
//  to a known issue with longer discount codes in versions
//  before 2.3.1. Could you confirm your current version?
//  In the meantime, here's a workaround: [steps]..."

// → Approved → Sent → Resolved in 4 minutes
// Memory: resolution pattern reinforced
Research Agent

Intelligence on autopilot

Crawls websites, analyzes competitors, synthesizes reports, and maintains a living knowledge base. Runs on schedule or on-demand. Feeds insights to Marketing, Product, and Strategy.

Web crawlingCompetitive analysisReport generationData synthesisTrend monitoring

End-to-end flow

1
Create task
"Weekly competitor product update: Cursor, Windsurf, Replit Agent — features, pricing, announcements"
2
Web crawling
Agent crawls competitor changelogs, blog posts, Twitter accounts, and Product Hunt pages. Extracts structured data
3
Analysis
Compares new features against SwarmOS feature matrix. Identifies gaps, threats, and opportunities. Scores each by impact
4
Report synthesis
Generates a structured report: Executive Summary, Per-Competitor Breakdown, Feature Gap Analysis, Recommended Actions
5
Obsidian update
Appends findings to Research/Competitor-Weekly/Week-{date}.md. Updates [[Cursor]], [[Windsurf]], [[Replit]] profile notes with latest data
6
Distribution
Summary posted to #product-intel Slack channel. Full report linked. Key threats flagged with @mentions
7
Review
You review the flagged items, mark 2 as action items → those auto-create tasks for the coding agent
8
Continuous
Runs weekly via scheduled task. Each report builds on previous context. Trend lines emerge over time in Obsidian
agent-log.txt
// Task: "Weekly competitor update — Week 10, 2026"
// Agent crawls:
//   - cursor.com/changelog
//   - windsurf.com/blog
//   - replit.com/blog
//   - Twitter: @cursor_ai, @windsurf_ai, @replit

// Output: Research/Competitor-Weekly/Week-10-2026.md
// ┌─────────────────────────────────────────────┐
// │ Executive Summary                           │
// │ • Cursor shipped multi-file edit (threat: 8)│
// │ • Windsurf added MCP support (threat: 6)    │
// │ • Replit pricing unchanged (opportunity)     │
// │                                             │
// │ Recommended Actions:                        │
// │ → Prioritize multi-file orchestration       │
// │ → Blog post: "SwarmOS vs single-agent IDEs" │
// └─────────────────────────────────────────────┘
// → 2 action items created as new tasks
Bug Fix Agent

From Sentry alert to merged fix

Investigates bug reports end-to-end: reproduces issues, traces root causes, writes fixes, adds regression tests. Integrates with Sentry, Linear, and your test suite.

DebuggingRoot cause analysisRegression testingLog analysisHotfix deployment

End-to-end flow

1
Bug report
Sentry alert: "TypeError: Cannot read property 'id' of undefined" in checkout/payment.ts:142 — affecting 340 users in the last hour
2
Coordinator assigns
Coordinator sees "debugging" skill requirement, assigns to coder-2 (bug fix specialist). Priority: High
3
Investigation
Agent reads the stack trace, pulls checkout/payment.ts, traces the data flow. Checks git blame for recent changes to that file
4
Root cause
Identifies: PR #847 (merged 2 hours ago) changed the payment response schema but didn't update the null check on line 142. The optional chaining was removed
5
Fix implementation
Agent writes the fix: restores optional chaining, adds a schema validation guard, and adds a null-case fallback that returns a user-friendly error
6
Regression tests
Writes 3 test cases: null payment response, partial response (missing id), and valid response. All pass. Existing tests still pass
7
Quality gates
TypeScript ✓ → Tests (47/47) ✓ → Lint ✓ → Build ✓. Auto-Iterate not needed — passed first try
8
Review & deploy
PR created with Sentry issue link, root cause explanation, and test coverage. You approve. Deployed. Sentry alert resolves within minutes
agent-log.txt
// Sentry: TypeError at checkout/payment.ts:142
// 340 users affected, started 2 hours ago

// Investigation:
//   git log --oneline checkout/payment.ts → PR #847 (2h ago)
//   Diff: removed optional chaining on response.data?.id

// Fix: checkout/payment.ts
- const orderId = response.data.id;
+ const orderId = response.data?.id;
+ if (!orderId) {
+   logger.error("Payment response missing order ID", { response });
+   throw new CheckoutError("PAYMENT_PROCESSING", "Please try again");
+ }

// Tests added:
//   ✓ handles null payment response
//   ✓ handles partial response (missing id)
//   ✓ processes valid response correctly

// Gates: ✓ tsc ✓ jest (47/47) ✓ eslint ✓ build
// PR #851 → Approved → Deployed → Sentry resolved

Ready to build your AI team?

Start with the free sandbox. Add agents as you grow. Every task makes them smarter.