There's a particular kind of fatigue that hits you around month 18 of running a solo dev consultancy.

It's not burnout from coding. It's the meta-work — the invisible scaffolding of tools you've assembled to do the work. I had Notion for docs, Linear for tasks, Superhuman for email, Zapier automations talking to five different APIs, a custom Python script that scraped client data every morning, and approximately four browser windows open at any given moment just to context-switch between roles.

The real cost wasn't the ~$400/month in subscriptions. It was the cognitive overhead of being the integration layer between all of it.

When I stumbled across Floatboat, I was skeptical. Another "all-in-one" workspace? I've been burned by that promise before. But something about the positioning caught me — desktop-native AI agent, not a web app. Local file access. A learning engine that observes how you work.

That last part made me put down my coffee and actually read the docs.

Why Desktop-Native Actually Matters (And Why Most AI Tools Get This Wrong)

Let me start with the architecture problem that most browser-based AI tools never solve.

When you use ChatGPT, Claude.ai, or any web-based AI assistant, there's a fundamental mismatch between where your data lives and where the AI operates. Your files are local. Your email client is local. Your calendar is local. But the AI is running in a tab that's sandboxed from your operating system.

The result? You end up doing a lot of copy-paste. You export a CSV, paste it in, get output, copy that output, paste it into your next tool. The AI becomes a smart text transformer, not an actual agent.

Floatboat's approach is architecturally different. It's a desktop application — macOS (ARM and Intel) and Windows — with actual system-level access. This means:

Local file system
       ↓
  Floatboat agent
       ↓
Native OS integrations (macOS Reminders, local email client)
       ↓
3,500+ cloud API connections

Instead of you being the bridge between tools, the agent is. That's a fundamentally different model.

The Modular Workspace: Expanding Context Windows for Real Work

One thing that immediately struck me was the workspace design philosophy. Rather than giving you a fixed UI and asking you to adapt, Floatboat starts minimal — just a chat interface — and expands based on what you're actually doing.

Working on a document? A file manager panel slides in. Writing code? A preview pane opens alongside. The split-screen functionality isn't a gimmick — it's the product's acknowledgment that real work involves multiple context streams simultaneously.

As a developer, I think about this like multi-threaded execution. Most AI tools give you a single thread: ask a question, get an answer, ask again. Floatboat's workspace is designed more like async operations running in parallel — you can have a document open, an agent processing something, and a browser view active at the same time.

The file preview support is comprehensive: Markdown, code, Word, Excel, video. That last one surprised me. Being able to reference a video file from within the same workspace where your AI agent operates starts to collapse the distance between research and output.

The Tacit Engine™: How It Actually Learns (The Interesting Part)

Here's where I spent most of my time thinking, because this is the genuinely novel piece.

Floatboat has something they call the Tacit Engine™, and it's named after the concept of tacit knowledge — the stuff you know how to do but can't easily articulate. Michael Polanyi's "we know more than we can tell." The idea is that an AI workspace shouldn't require you to explicitly program workflows. It should watch you work and build a model of your patterns.

The practical implementation of this is what they call Combo Skills.

Think of Combo Skills as reusable workflow packages built from your actual usage patterns. If you regularly:

1. Pull data from a client's project management tool
2. Format it into a specific report structure
3. Send a summary email with specific language patterns
4. Add a follow-up reminder

...the Tacit Engine observes those steps across multiple sessions and begins packaging them. The result is a Combo Skill that you can invoke without rebuilding that workflow from scratch every time.

Observed behavior pattern:
  → Agent records action sequence
  → Identifies repeating structure
  → Packages into addressable Combo Skill
  → Available via Combo Store (browse/share)

This is materially different from traditional workflow automation tools like Zapier or n8n, where you define the flow explicitly. The tacit approach tries to extract workflow structure from behavior rather than requiring you to model it in advance.

The philosophical bet here is interesting: most people can't accurately describe their own workflows, but they can consistently execute them. If the engine can observe consistently, it can learn tacitly.

3,500+ Integrations: The Real Number Behind the Claim

Every tool claims integrations. Let me put this number in context.

Zapier has ~6,000+ integrations. Make (formerly Integromat) has ~1,500. Native integrations in a single desktop app at 3,500+ puts Floatboat in a different tier than most single-purpose tools — and the architecture here matters. These aren't just webhooks. The combination of:

• Local file access (direct system integration)
• Browser automation (navigating web services, scraping data)
• API connections (3,500+ cloud tools)
• Native OS integrations (macOS Reminders, local email client)

...means the integration model spans from system-level to cloud-level in a single agent context. That's the technical moat that's harder to replicate than the feature set might suggest.

For a solo developer running a consultancy, this means the agent can:

• Pull a client brief from a local folder
• Cross-reference it with data from a cloud project management tool
• Generate a proposal draft
• Stage it in your email client
• Set a follow-up reminder in macOS Reminders

Without you switching apps once.

"Selfware": The Concept I Wish I'd Named

There's a term Floatboat uses that I keep coming back to: Selfware.

The idea is that instead of buying pre-built software that approximates your needs, you generate contextual tools specific to your exact task, at the moment you need them. It's software that is literally generated for you, by you, in the moment.

As a developer, I recognize this as a specific pattern: just-in-time tooling. Rather than maintaining a library of scripts and automation tools that you have to keep updated, organized, and remembered — you describe what you need and it materializes.

The implication for solopreneurs and indie developers is significant. Right now, if I want a custom data transformation, I either:

Selfware proposes option d:

d) Describe the transformation to the agent in the context where you need it, and it executes it in place (time: ~2 minutes, no artifacts left behind to maintain)

The "no artifacts left behind" part is actually a feature, not a limitation. Accumulated tooling debt is real. Every script you write is a script you have to eventually maintain, document, or delete. Ephemeral Selfware eliminates that entirely.

The One-Person Company Thesis

I want to dwell on the target audience framing here because it's technically interesting, not just marketingspeak.

Floatboat explicitly positions itself for one-person companies — founders, solopreneurs, and small operators who are simultaneously executing across roles that would normally be split across a team. That's:

• Developer
• Product manager
• Sales
• Marketing
• Finance
• Customer support
• Legal review
• Operations

In a traditional company, each of these functions has its own tooling, its own data flows, and its own specialists who know how to use them. A one-person company has the same complexity, compressed into a single human's working day.

The AI agent architecture makes sense here because you're not automating a single workflow — you're automating context switching itself. The agent holds the full operational context of the business and can shift between roles with you, rather than you having to manually re-orient for each.

Three concrete use cases from their product positioning that illustrate this well:

1. Sales → Marketing Bridge
A sales professional converts voice notes from a client call into a presentation deck. This typically involves: transcription, key point extraction, slide structure mapping, visual design output. Four different tools, or one agent with context.

2. Content → Publication Pipeline
A content creator transforms scattered research notes into publish-ready articles. The agent knows your writing style (learned from past output), your target audience, and your publication format requirements. The output isn't a draft — it's something actually close to publishable.

3. Legal → Business Strategy
A business owner conducts a contract review and extracts strategic implications. Normally this requires: contract parsing, legal knowledge, business context, and synthesis. An agent with full business context can do the synthesis step meaningfully.

In each case, the value isn't just automation — it's contextualized automation. An agent that knows your business context produces qualitatively better output than one that treats each task in isolation.

What This Means for the Developer Building Solo

Let me get specific about my own use case, because I think the developer audience here will relate to it.

I've been building and maintaining a small portfolio of micro-SaaS products alongside consulting work. The context switching cost is brutal. When I'm deep in a client debugging session and need to switch to responding to a potential new customer's technical questions about one of my products, the mental overhead of that switch is significant.

The Floatboat model addresses this specifically. If the agent has context on:

• My client's codebase and the current debugging thread
• My product's technical documentation
• My standard tone and language patterns for sales conversations

...then the context switch cost becomes: "hey, there's an email from a prospect, here's a draft response that maintains technical accuracy to the product docs and my sales voice."

That draft might be 80% right. I review, tweak, send. The cognitive load is management, not creation.

The other piece that matters to me as a developer is the browser automation capability. I do a fair amount of research-intensive work — competitive analysis, tracking developments in specific technical areas, monitoring certain forums and communities. Browser automation that can execute structured research tasks and return synthesized findings (rather than just links) is a genuinely different capability than search.

Honest Assessment: Where the Rough Edges Are

I'm not here to write marketing copy, so let me be straightforward about where I think this category of tool has real challenges.

The cold start problem. The Tacit Engine learns from observation, but learning requires sessions. The tool is most valuable after it has context on how you work, which means the first few weeks are necessarily less impressive. Every tool that learns from usage has this problem; it's not unique to Floatboat, but it's real.

Trust in a system with system-level access. A desktop agent that has access to your local files, email client, and can automate browser actions is operating with significant privilege. For developers, the security model here deserves scrutiny. What leaves the machine? What's processed locally vs. in the cloud? These are questions worth asking directly before adopting any tool with this access model.

The Combo Store is early. The marketplace for shared Combo Skills is the kind of feature that becomes dramatically more valuable at scale — both in terms of community-contributed workflows and in terms of the network effects from seeing how others use the tool. At this stage, it's more of a roadmap preview than a fully realized feature.

AI model dependencies. The pricing page references models including Claude Opus 4.6 and Gemini 3.1 Pro. An AI workspace's utility is partially dependent on the underlying model capabilities, which means it inherits the constraints, costs, and occasional regressions of those APIs. That's a trade-off compared to a purely local model approach.

The Broader Pattern: Why "AI Workspace" Is Architecturally Different from "AI Chat with Integrations"

Let me zoom out to the structural point, because I think it's underappreciated.

There's a generation of AI tools that are essentially: chat interface + integration layer. You can think of these as API orchestrators with a conversational front-end. They're useful, but they have a fundamental shape to them: you ask, they fetch, they respond.

An AI workspace is a different architectural shape. The key differences:

The "actions in the actual environment" piece is the crux of it. An AI workspace doesn't produce text that you then have to act on. It acts. The distinction matters because it eliminates an entire category of cognitive overhead — the step where you take the AI's output and do something with it.

Practical Takeaway: How to Evaluate Whether This Fits Your Stack

If you're considering Floatboat or evaluating this category of tool, here's the framework I'd use:

High fit if:

• You're operating solo or in a very small team (< 3 people) with high role diversity
• You spend significant time on cross-tool information assembly (copy-paste between apps)
• You have repeating complex workflows that you can't efficiently automate with existing tools
• You work on macOS or Windows desktop (obviously) and your work is local-file-centric
• You're comfortable with a learning curve in exchange for compounding productivity returns

Lower fit if:

• Your workflows are already well-automated (good Zapier/n8n setups running smoothly)
• You work primarily in a browser-centric SaaS environment with no local files
• You need team collaboration features and shared workspaces
• You want something that's immediately productive on day one without observation/learning time

The test I'd run:
Map your last 5 complex work tasks. Count the number of app switches required to complete each one. If the average is > 4, the ROI case for a unified workspace agent becomes pretty compelling.

The Bigger Idea: Software Is Becoming a Runtime, Not a Product

I want to close with the conceptual shift that Floatboat's architecture represents, because I think it's where the industry is genuinely heading.

Traditional software is a product you buy. It has a feature set. You adapt your workflow to its capabilities. The product is static; you are the variable.

AI workspaces invert this. The "software" is increasingly a runtime environment — a set of capabilities, a learning substrate, and an integration layer — on top of which your specific workflows get instantiated. The software adapts to you, not vice versa.

The Selfware concept is the logical endpoint of this: software that is generated contextually, for your specific situation, at the moment you need it, by an agent that knows your business, your patterns, and your preferences.

We're early in this. The rough edges are real. But the architectural direction is clear, and Floatboat is building toward it with a coherent thesis: one person, one AI workspace, capable of operating at the scale of a small team.

For solo developers, indie hackers, and solopreneurs who've felt the weight of the SaaS subscription stack — this is the bet worth watching.

Check out Floatboat and form your own opinion. But if you do, give it a few weeks of real use before judging. The interesting part is what happens after it starts to know how you work.

If you're experimenting with AI workspaces or desktop AI agents, I'd love to hear what's working for you — drop it in the comments.