THE MANIFESTO
Every person has work only they can do. Everything else is noise. Arcanist exists to multiply what every person at a company can do, so the noise disappears and the real work gets done.
Engineering is being restructured. Not incrementally - fundamentally.
The best engineers at the best companies are no longer spending their days writing code. They're supervising systems that write code for them. They describe what they want, review what comes back, and move on. The ones who adopt this early are shipping faster than teams twice their size.
This is not a tooling upgrade. It's a paradigm shift. And it doesn't stop at code.
Every business process lives in software now. Hiring runs through Greenhouse. Sales runs through Salesforce. Ops runs through internal dashboards someone built in a sprint two years ago. The universal interface to modern work is code - not because everyone writes it, but because every system is built on it.
A coding agent isn't just an agent that writes code. It's an agent that can operate any software system. It can read your database, trigger your CI pipeline, parse your error logs, update your documentation, and file a PR - all in one session. The coding agent is the primitive that can manipulate any structured process in a company.
There's a fair objection here: software hasn't fully eaten the world. The context graph for knowledge work is fundamentally fuzzier than the context graph for code. In software, the key entities are code, commands, and outputs - structured, verifiable, deterministic. In knowledge work, the key entities are people, communications between them, and the timing of those communications. That's messier.
But here's the thing: all of that fuzzy context runs through software. The conversations happen in Slack. The decisions get tracked in Jira. The documents live in Notion. The data sits in Postgres. The context graph is fuzzy, but it's still traversable - through the systems people already use. A coding agent that can read Slack threads, query databases, and navigate internal tools can traverse that graph. Not because it understands people, but because it understands the systems people operate through.
That's why we're starting here. Not because code is the goal, but because code is the lever.
The industry is building AI coworkers. AI software engineers. AI teammates.
We think that's the wrong abstraction.
People don't want more coworkers. They don't want to manage another teammate, explain context for the fifth time, or review work that missed the point. They want someone who gets it - who takes away the parts they don't want to deal with so they can focus on the parts that matter.
They want a minion, not a coworker.
This is a product philosophy, not a branding choice. It changes what you build. A coworker needs to be onboarded, managed, and supervised. A minion needs to understand your intent and disappear into the work. The bar isn't "can it write code?" - it's "did the thing I needed get done without me thinking about it?"
This distinction also determines whether you survive the adoption curve. Right now, companies are going through a predictable cycle: force every employee onto AI tools, watch token costs spike 5-25% per head, see some green shoots and demos, then hit the valley of despair when the expected productivity gains don't materialize. Upskilling everyone turns out to be hard. Most of the AI output creates more review work, not less. The "coworker" abstraction is the direct cause - it adds a new entity to manage without removing any existing work.
The "minion" abstraction is the way out of the valley. If the agent actually removes work instead of creating new work - if the engineer's day gets shorter, not longer - then you skip the disillusionment phase entirely. The metric isn't "how much AI output did we generate." It's "how much human time did we reclaim."
And reclaiming time is just the first unlock. The real superpower is parallelization. Today, an engineer can hold maybe two or three threads of work in their head at once. With a minion that understands your codebase, your CI, and your conventions, you can run dozens of tasks concurrently. The bottleneck shifts from your compute to your supervisory capacity. You stop being the person who does the work and become the person who directs it. That's not a marginal improvement - it's an order-of-magnitude change in what one person can accomplish.
Most of what makes an agent actually useful is locked behind context that no model can learn from pretraining. How does this company's CI work? What are the naming conventions? Who owns what service? What does the deploy process look like? No amount of training data will teach an agent these things. They have to be learned through integration, through usage, through being embedded in the workflow.
That's why we're building a factory of trained, steered agents - not a generic AI that can do everything, but a system that can be shaped to do exactly what your team needs.
This also reshapes an entire industry. The $200B IT services model - Infosys, TCS, Capgemini, Cognizant - sells human hours. Hire in Bangalore at $15/hour, bill in New York at $80/hour, pocket the spread. That model is already cracking: India's Big 4 IT firms have stopped hiring; TCS cut eleven thousand people in a single quarter. And this is before AI agents are widely deployed in enterprise.
But the work those firms did - integrating, customizing, maintaining company-specific software - still needs to get done. Companies still need their specific workflows understood and automated. The delivery model changes: agents instead of armies. The people who used to spend their days on rote integration work get to move up to the work that actually requires human judgment. The factory of trained, steered agents handles the rest.
Claude, GPT, Gemini, open source models - all converging in raw capability. When the engine becomes a commodity, the value shifts up the stack. The game is no longer "who has the best model." It's "who best understands how a company actually operates."
The evidence for this is already concrete. Studies replicating production agent systems have shown that smaller models with strong context engineering - detailed system prompts, carefully injected reminders, tool descriptions that codify workflow knowledge - outperform larger models running without that steering. Haiku with good orchestration outperforms Opus without it. The impact of context engineering on output quality cannot be overstated. The entire performance curve depends not on which model you use, but on how well you steer it.
This is what we mean by the "factory of trained, steered agents." The model is an engine. The value is in the tuning - the system prompts, the integration points, the organizational context that tells the agent how this specific company works. That tuning is what we build. And every deployment teaches us more about how companies work. How teams communicate, how code flows from idea to production, where the friction lives. That knowledge compounds. It makes every subsequent deployment better, every agent sharper, every integration more useful. This is not a moat you can build in a weekend. It's one that deepens with every customer.
Open source gives you the 80%. There's a lot of noise right now about LLM tools killing SaaS, but new technology has always produced a cambrian explosion of new software, not less. The game is evolving, not dying.
And the history is clear: PostgreSQL is free, yet managed databases are a massive market. Linux is free, yet AWS prints money. The 80% - the generic capability - commoditizes. The 20% - the edge cases, the maintenance, the integration with your specific stack, the custom workflows, the things that break at 2am - that's where the value lives. And that 20% is different for every company.
You can't pip install organizational context. You can't open-source your way to understanding how a specific team operates. We build that last mile.
A JPM analyst reacting to the latest wave of AI tooling: "It feels like an illogical leap to extrapolate from Claude Cowork Plugins, to this expectation that every company will hereby write and maintain a bespoke product to replace every layer of mission-critical enterprise software they have ever deployed." He's right - it is an illogical leap. Companies won't do it themselves. That's the opportunity.
Arcanist meets you in Slack. Not a new IDE. Not a new platform. Not another tab to keep open.
This isn't just a UX decision - it's a distribution strategy. Bottom-up adoption in the enterprise is rare and powerful. One engineer adds Arcanist to a channel. The team starts using it. Usage spreads organically before anyone writes a procurement memo. By the time it hits a buying decision, it's already embedded in the workflow.
And because we're platform-agnostic - we use the best models, the best tools, the best infrastructure for the job - we're not constrained by the need to upsell our own AI add-on. Every current SaaS company is bolting on AI features to protect their position. We have no position to protect. We just need to be the most useful thing in the room.
The market is having a category error. It's selling "software" as a monolith, but within software there are two fundamentally different kinds of companies. There's software humans click on - dashboards, CRMs, project management tools, anything with a UI that a person stares at for eight hours a day. And there's software bots call - APIs, databases, event streams, monitoring, authentication. The infrastructure layer.
AI transforms the first category. When an agent handles the rote work, people stop living inside dashboards and start doing the thinking those dashboards were supposed to enable. The seat-based model compresses - not because people disappear, but because the work changes shape.
AI feeds the second category. Every agent still needs to authenticate, query a database, send a notification, log its actions, stream events. And agents consume orders of magnitude more than humans - one human generates a few dozen API calls per hour; one agent generates hundreds per minute.
Arcanist is a consumption multiplier. Every task we dispatch hits Sentry APIs, triggers CI pipelines, queries databases, logs to Datadog, pushes to GitHub. We generate massive downstream infrastructure consumption. But we're not just a pass-through that enriches the infrastructure providers. The organizational knowledge - knowing which calls to make, in what order, with what context - is what makes us a tollbooth in our own right. The infrastructure providers sell plumbing. We sell the intelligence that knows how to use it.
CFOs are already making this trade. Budgets are shifting from seat-based software and manual labor toward compute and agent infrastructure. The money is moving from road workers to tollbooths. That's the demand curve for what we're building.
The space is crowded. GitHub Copilot, Cursor, Devin, Codegen, and dozens of others are all building some version of "AI for software engineering."
But they're all solving the problem at the technical level. Build a better autocomplete. Build an AI engineer. Build a smarter IDE. The competition is optimizing for capability.
We're optimizing for something different: actually helping people.
That sounds obvious, but it's not what's happening. A tool that can write code but doesn't understand your CI pipeline hasn't helped you. An AI engineer that opens a PR but doesn't know your team's conventions hasn't saved you time - it's created review work. Capability without context is noise.
The model providers themselves are pushing up the stack - Anthropic is shipping Cowork, Excel plugins, PowerPoint integrations. This is both validation and clarification. Their incentive is to sell tokens across millions of users. Ours is to deeply integrate into how specific companies operate. They're building breadth. We're building depth. They make the engine better; we make it useful for your company. These are different games, and they're complementary, not competitive.
Our thesis is that the winners in this space won't be the ones with the most technically robust AI. They'll be the ones who most deeply integrate into how companies actually function. The ones who reduce the total surface area of work, not just the coding part of it.
Everyone is building for the capability curve - better models, more features, more AI surface area. Almost nobody is building for the adoption curve - the valley of despair, the upskilling problem, the fact that companies genuinely don't know how to restructure around AI. Leadership is aggressively pushing AI adoption and shifting budget from seat-based software to consumption-based compute. Engineers are being told to use these tools. Token budgets are spiking. And in most organizations, the result is chaos: tons of make-work, no actual progress, and a growing suspicion that the productivity gains were overpromised.
The adoption problem is the harder problem. And it's the one that matters. We're building for it.
We start with coding because code is the lever. But the vision is larger.
Every piece of structured knowledge work - documentation, data pipelines, ops tasks, reporting, compliance - follows the same pattern: understand the context, do the work, verify the output. The same agent architecture that can ship a PR can update a runbook, build a report, or triage an incident.
Act 1 is the autonomous coding agent. It works today. It ships PRs, self-heals when CI fails, and connects to your full stack.
Act 2 is the developer platform. Multi-repo support, learned conventions, every customer's stack becoming a first-class integration. The agent gets better the more you use it.
Act 3 is the knowledge work platform. A unified system for dispatching, supervising, and verifying autonomous agents across every function in a company. Code was the wedge. The platform is the product.
Act 3 is also the hardest act - and we're honest about why. The context graph for knowledge work is fuzzier than for code. You can't just point a model at Slack and expect it to understand how a company functions. The skills required are personal, context-dependent, and continuously evolving. This isn't a feature you ship. It's a capability you learn - through the compounding organizational knowledge built in Acts 1 and 2. Every integration we build, every workflow we automate, every edge case we solve teaches us more about how companies actually work. By the time we reach Act 3, we won't be guessing at how to do knowledge work. We'll have learned it from the inside.
Do the work you were meant to do.
That's the future. Not humans replaced by machines. Humans freed from the parts of work that waste their time, empowered to focus on the parts that only they can do.
We're building Arcanist to make that real.