we are a two-person team running a venture-backed software company. to operate at the scale and velocity our vision requires, we have had to become an agent-native software factory.
our leverage does not come from one model or one autonomous agent running the company. it comes from integrating specialized agents across the production system. we wanted to share how we are using them, how they work together, and how we think about their value.
this is not one agent running the entire company, and it is not a leaderboard of model intelligence. it is a production system. an idea or customer signal moves through research, product thinking, specification, implementation, testing, review, documentation, distribution, and monitoring. different agents are useful at different stations. we set the direction, permissions, and acceptance criteria; the agents compress the work between those decisions.
that is what “software factory” means for us. not replacing two people with a digital workforce, but giving a two-person company enough parallel capacity to operate like a much larger team without inheriting the same coordination overhead.
working this way has also convinced us that the industry is using the wrong unit of analysis.
the value of an agent is not intelligence per dollar. it is completed work per dollar, per permission, and per minute of human attention.
that matters because we are moving from an era of engagement to an era of immersion.
engagement is opening a chat, asking a question, reading the answer, and moving the result somewhere else. the model is intelligent, but it is still behind glass. the user remains the router between the model and every application where the work actually happens.
immersion begins when the agent can enter the environment of the work, the social feed, browser, editor, repository, terminal, inbox, calendar, files, cloud computer, and eventually the operating system itself. it can retain context, use tools, make changes, verify the result, and return only when it needs a decision.
this is why access is becoming as important as model quality.
the boundary between intelligence and software is becoming porous, but that porosity is arriving through granularity.
which folder can the agent read?
which repository can it change?
can it use the network?
can it draft an email but not send it?
can it add someone on LinkedIn and add a note?
can it create a video with good enough quality?
can it schedule, publish, deploy, or delete? for how long? with whose approval?
the best agent products are not simply adding more intelligence. they are designing a permission system around intelligence.
this also changes how we should think about cost.
there are at least four costs:
1. the subscription price.
2. the marginal compute cost: tokens, model calls, browser steps, tool calls, subagents, retries, and generated artifacts.
3. the coordination cost: prompting, supplying context, watching progress, correcting the plan, and moving outputs between apps.
4. the trust cost: reviewing code, checking citations, approving actions, and deciding how much access the agent should have.
a cheap model can be expensive if it returns work we must reconstruct. an expensive agent can be cheap if it completes a workflow that would otherwise consume hours. and a flat subscription can be extraordinarily valuable because it removes the anxiety of paying for every experiment.
that is why the new x subscription is such a powerful bundle.
at the premium tier, one subscription combines grok, grok bot, cursor, and x premium, with a shared pool of grok model usage. that is not just a discount across four products. it connects four surfaces in one economic loop:
grok is the thinking and media layer.
grok bot is the persistent worker layer.
cursor is the local and cloud software-building layer.
x is the distribution, feedback, and audience layer.
the loop can move from an idea, to research, to code, to a published artifact, to real world feedback without asking the user to buy and meter a different tool at every step. third party models in cursor can still create separate usage costs, but the included grok allowance makes the default path feel abundant and predictable.
that predictability changes behavior. when marginal usage feels close to zero, we delegate earlier, iterate more, and give the agent harder work. the subscription is not only buying tokens. it is buying the confidence to stay immersed.
chatgpt and codex have a similar advantage.
the chatgpt subscription is valuable because it spans two different modes of work under one identity and allowance. chatgpt is the general reasoning and communication surface. codex enters the repository, reads the surrounding system, edits files, runs commands, checks tests, and leaves an inspectable trace of what it did.
this is a crucial difference. asking a model how to fix software is engagement. giving an agent a scoped repository, a terminal, and permission to verify the fix is immersion.
the economic value of codex is not that it writes code faster than a person can type. it compresses the entire loop of understanding, implementation, testing, review, and iteration. the usability value comes from granular access: it can be powerful inside the folder or branch we authorize without automatically receiving the keys to the rest of the machine.
claude and claude code form the same kind of subscription pair, with a different center of gravity.
claude is exceptionally useful when the hard part is holding a large conceptual object in mind, a strategy, a long document, an architecture, a nuanced critique, or a decision with many constraints. claude code moves that reasoning into the terminal and repository. the pro and max subscriptions share usage across both surfaces, which means the same monthly relationship can support thinking, writing, analysis, and implementation.
for us, claude is often the best editor and systems thinker, codex is often the best execution environment. they overlap, but their usability is not identical. that is why “which model wins?” is less useful than “where does each product let the model act, and how much friction remains between the thought and the finished work?”
muse also scores highly on value because it is making multi-agent work inexpensive and legible. parallel workers are not very useful if their activity becomes an opaque cloud of hidden calls. muse’s emphasis on observable agents, replayable actions, and lower-cost model access matters because it reduces both marginal compute cost and the trust cost of delegation. it is especially compelling for work that benefits from fan-out—implementation, review, testing, and computer-use tasks running as coordinated roles rather than one long conversation.
perplexity computer may be the clearest expression of the immersive future, and also the clearest explanation of why that future is expensive.
it does not merely answer a question. it decomposes a project, selects among models, runs supporting agents, searches, browses, connects to apps, creates files, writes code, and can continue in the background. a single request may become dozens of model calls and tool actions before a final artifact appears.
that is why it can feel magical. it is also why its economics look more like an api bill than a chat subscription. every additional branch of reasoning, model handoff, browser loop, retry, and generated asset consumes real compute. the credit system makes that hidden fan-out visible to the user.
perplexity computer is worth it when the workflow itself has high value, a deep market map, a continuously monitored topic, a researched and cited report, a dataset turned into a presentation, or a small application taken from prompt to deployment. it is poor value when we use a multi-agent computer to answer something that one search or one model call could handle.
the right question is not “is perplexity computer expensive?” it is “did we assign it a computer-sized task?”
hark is testing a different form of immersion, the personal operating layer. its promise is not primarily better prose or better code. it is persistent context plus browser action across travel, reservations, expenses, shopping, email, appointments, and recurring personal administration.
that category has enormous potential, but its usability threshold is brutal. for personal operations, a task that is 90% complete can be worth almost nothing. a restaurant is either booked or it is not. an expense is either submitted or it is not. a flight purchased incorrectly may create negative value. hark becomes valuable when granular approvals, memory, and reliability make delegation easier than direct action. until then, the supervision cost keeps it in the middle of the matrix.
duet shows the opposite problem, broad capability does not automatically become usable value. it offers agents, integrations, hosted workflows, and business automation, with model tokens passed through at api cost. there is no platform or per-seat fee, which is attractive, but the variable token bill, setup, and ongoing supervision still enter the calculation. and frankly duet is pretty bad today, potentially the worst of all agents we use.
this is the deeper pattern behind our matrix:
• x + grok + cursor are powerful because one subscription connects thinking, building, and distribution.
• chatgpt + codex are powerful because one subscription connects general intelligence to an inspectable execution environment.
• claude + claude code are powerful because one subscription connects deep synthesis to terminal-level action.
• muse is powerful because it makes coordinated agent work cheaper and more observable.
• perplexity computer is powerful because it can orchestrate a complete cross-app workflow, but the fan-out of models and tools creates real marginal cost.
• hark will be powerful when personal delegation becomes reliably easier than doing the task ourselves.
• duet will be powerful when a repeated business workflow amortizes the setup, credits, and supervision. and when it becomes way better.
the winning product will not necessarily have the smartest model.
it will have the best relationship between intelligence, access, economics, and trust.
it will know enough, reach the right surfaces, ask for the right permissions, expose enough of its work to be corrected, and complete the task before the user becomes the agent’s project manager.
usable autonomy per dollar and per unit of attention.