You don't want a software factory. You want a software workshop.
Software factories are rigid pipelines. BitsWeave is the software workshop: composable AI agent tools you use freeform, then bundle when work repeats.
A software factory promises a finished line: feed work in, get software out. A software workshop is the opposite bet. You walk in, pick up tools, and build the workspace the job needs.
The factory pitch is easy to sell. One end-to-end workflow. One happy path. One dashboard that says the pipeline ran. That is also why factories break. Even a simple website is not a linear assembly. Requirements move. Copy changes after the layout is "done." Auth, analytics, and a CMS each carry their own exceptions. The uncertainty is not a defect in the project. It is the work.
BitsWeave is the software workshop. Its features are the tools on the bench. You do not buy a sealed production line. You enter the shop and assemble the agentic workspace you actually run.
The software factory is a brittle story
"Software factory" language showed up because factories are easy to diagram. Stations. Handoffs. A last station that stamps "done." Vendors now sell the same picture for agents: ingest, plan, execute, ship. The pipeline is the product.
That model fails the moment the work is not a repeat of last week's run.
A factory is optimized for identical units. Software is not. A landing page, a billing edge case, a support ticket that turns into a schema change — each one branches. The factory answers with more stations and a longer "e2e workflow" that tries to pre-decide every fork. You get a pipeline that is expensive to change, easy to skip, and wrong the first time a human has to improvise.
A rigid workflow has one legal path. When reality leaves that path — a missing field, a rejected option, a teammate who already decided the opposite — the factory either stops or invents a confident wrong next step. People become the exception handler. They paste context. They tell the next agent what the last one already knew.
Scale does not save it. Ten agents on one factory line still share one assumption: the work will look like the diagram. It will not.
A workshop automates the task, not the whole job
A workshop is not the opposite of automation. Good shops automate constantly. A drill press is automation. A well-tuned agentic tool is automation. The difference is grain.
Factories automate the job as one workflow. Workshops automate tasks as tools you can pick up.
That is the whole thesis. Instead of a rigid end-to-end workflow, you build composable tools that work well together. You use them independently, freeform, while you are still figuring the work out. When a sequence becomes repetitive, you bundle those tools into a larger run. You do not start from the bundle. You earn the bundle.
This is how people already work when the software is honest. You search an issue, read a spec, comment on a pull request, write a note. None of those steps needed a factory to pre-authorize the day. They needed tools that stay available when you switch windows.
AI agent tools are only useful if you can reach for them in the moment, not only as step four of a stored pipeline. Agentic tools should compose: a broker call, a skill, a document, a record. Use one. Use three. Later, if the trio repeats every Monday, bind them.
The factory asks you to model the business before you understand the work. The workshop lets the work teach you which motions are worth saving.
BitsWeave is the shop. The features are the tools.
BitsWeave is not a sealed orchestration product. It is the room you walk into. Brokers, skills, documents, records, and the MCP surface are the tools on the wall. You connect Claude, Cursor, ChatGPT, and other MCP clients, then build the workspace that gets agentic work done.
Four tools matter for this argument. They are what is on the bench.
Stable access to the apps you already run
A workshop without materials is a showroom. Agents need the same apps your team already trusts: GitHub, email, observability, ads, a webhook from something custom. BitsWeave reaches those systems through brokers. A broker is a two-way connector. Events come in. Actions go out. Credentials stay with the organization.
Your agent does not hold the GitHub token. It asks BitsWeave to read a diff or post a review. The call is authenticated, scoped, and logged.
The MCP surface is how that bench is presented. Add the BitsWeave MCP server once. The agent searches, inspects, and calls tools through one audited interface — tools.search, tools.get, tools.call — plus the domain seeds for documents, records, sessions, and brokers. Install a broker, and its action tools show up on that same surface. Uninstall it, and they leave.
Factories hide this behind a pipeline step named "sync Jira." Workshops put the connected app on the bench and let you use it when the work needs it.
Composable skills, plus the tools you add
A stored end-to-end workflow is a factory drawing. A Skill is a workshop drawing: a typed graph with SKILL.md semantics that an agent can run when the motion is worth repeating. Skills replaced stored Actions and Workflows on purpose. You keep a composable plan you can run with skills.run.
That is the bundle side of the thesis. Freeform first. Bind later.
The other half is custom tools. Brokers add them when you connect an app. Agents call brokers.<definition>.<type>.<op> the same way they call anything else on the MCP surface. A skill can include those calls. You can also skip the skill and ask for the one tool.
If a sequence is still exploratory, stay freeform. If it is now "every time a PR opens, do these three things," put it in a skill. The workshop does not force that choice on day one.
For the multi-step shape itself — plan, tool, check, next step — see agentic workflows. This post is the room those runs happen in.
Global documents and records
Tools without a workbench dump chips on the floor. Documents and records are the bench.
Documents are the durable prose the team and its agents can point at: the brief, the note, the page that should outlive a chat. Agents create them over MCP. People open them in the same org. They are not a transcript. They are an artifact.
Records are the structured objects the work hangs on: issues, accounts, projects, tasks, whatever schema the org actually uses. Broker events can map into records. Custom records live in the same substrate. Agents query them, link them, and update them through one permission model.
This is the same grain agentic memory argues for. Shared team context is not a longer chat. It is decisions, records, and next steps that survive the session. The context graph is how you walk that neighborhood from a focal record.
A factory stores "run history." A workshop stores the work. The next agent should pick up the document and the record, not a summary of last Tuesday's thread.
The same bench in Claude, Cursor, and ChatGPT
A factory that only runs inside one vendor suite is still a factory. Most teams do not live there.
Strategy happens in Claude. Implementation happens in Cursor. The stakeholder note happens in ChatGPT. If the tools only exist in one of those windows, you did not build a workshop. You built a sticky feature.
BitsWeave is host-agnostic on purpose. You add the MCP server to the agent you already run. The first call opens an OAuth consent. After that, Claude, Cursor, ChatGPT, and other Streamable HTTP clients see the same brokers, skills, documents, and records. Context written in one host is available when you, or a teammate, continue in another.
That is the only scale that matters for agentic teams: the bench does not move when the person or the model does.
Factory vs workshop
| Software factory | Software workshop | |
|---|---|---|
| What you buy | A rigid end-to-end workflow | Composable tools on one bench |
| How work starts | The pipeline starts you | You pick up a tool |
| When automation shows up | The whole job is pre-modeled | Tasks are automated; jobs stay flexible |
| Repeatable motion | Another station on the line | A skill you bind after it repeats |
| Connected apps | A hidden "sync" step | Brokers on a stable MCP surface |
| Memory of the work | Run history in one vendor | Documents and records in the org |
| Hosts | One suite | Claude, Cursor, ChatGPT, and other MCP clients |
| Failure mode | The exception kills the line | You change tools and continue |
Both pictures use automation. Only one survives a website that will not sit still.
How to tell what you are being sold
Five questions. They are enough.
- Can I use the tool without entering the workflow? If the GitHub call only exists as step three of a stored pipeline, you bought a factory station. If you can call it freeform from Claude this morning and from Cursor tonight, you bought a tool.
- When a motion repeats, can I bundle it without rewriting the bench? Skills should wrap tools you already have. They should not replace them.
- Does the work land on documents and records the next host can cite? If the only output is a chat, the next session starts from zero.
- Do Claude, Cursor, and ChatGPT share the same connected apps? If each host has a private plugin story, you are collecting factories.
- When the website (or the ticket, or the schema) changes, who edits the path? In a factory, you file a change request against the pipeline. In a workshop, you pick up a different tool and keep going. You save a new skill only after the new motion is real.
If the answers lean pipeline, one suite, and pre-modeled jobs, you are shopping for a software factory. If they lean composable AI agent tools, shared records, and mixed hosts, you want the workshop.
Enter the shop and build the workspace
The factory will keep selling certainty. It will keep failing on work that has uncertainty in it — which is most software, including the "simple" website.
A workshop is the honest product. Automate the tasks that deserve it. Use the tools freeform while you learn. Bundle them when a sequence earns a skill. Keep apps on one brokered MCP surface, artifacts in documents and records, and the bench available in every host you already open.
That is BitsWeave. You do not install a production line. You walk into the software workshop and build the workspace that gets agentic work done.
Connect Claude, Cursor, or ChatGPT at bitsweave.com. The tools are already on the wall.