The starting point
Coding with agents is no longer enough
With one chat per developer, the bottleneck is still the person who asks, watches and reviews.
Everything goes through someone
Every task waits for a person to request it, follow it and review it. Opening more chat windows does not change that.
Context gets lost
Every session starts from scratch: forgotten decisions, duplicated code and time spent re-learning the project.
Everyone does it their own way
Without a common process there is no way to audit what the agent did or to improve the whole team’s results.
What it is
Any repeatable, auditable process with AI inside
Repeatable
The same task always follows the same path.
Auditable
Every step leaves a trace: what went in, what came out and where it failed.
Three kinds of step
Deterministic. Always does the same thing and cannot be skipped: tests, scans, blocking rules.
Reasons over its input: drafts the specification, builds, reviews.
Approves what matters: high-impact changes and business decisions.
How it works
The production line, step by step
Every task follows the same path with its own identifier and its own branch; many can move in parallel.
- Step 1 Code
Intake
A production bug, an issue or a chat request. Everything comes in through the same place.
- Step 2 Agent
Specification
An agent writes down what will be done, after checking the project memory.
- Step 3 Agent
Build
Its own branch and tests first: write the test, then the code that passes it.
- Step 4 Agent
Parallel review
Security, code, UX and UI, with models different from the one that built it.
- Step 5 Agent
Approver
Gathers the reviews. If something fails, it sends the task back to build.
- Step 6 Code Person
Risk gate
Classifies the change by risk and sets how much human review it needs. A person merges.
↺ If a review fails, the Approver sends the task back to Build until it passes. Nothing moves forward with a review pending.
The foundations
The four pieces that hold up the factory
This is what SISCON already delivers as Harness Engineering; the factory puts it to work on every task.
Project memory
Decisions, architecture and constraints documented in a structured way and shared by the whole team.
Constitution
Rules the agent cannot skip because they are enforced in code: never to the main branch, never to production without approval.
Reusable tools
Scripts and connectors built once and reused, instead of improvised on every task.
Tests and evals
Tests before code and continuous evaluation, so quality is measured instead of left to luck.
Human control
A person reviews and merges every change
The factory classifies every change by risk and adjusts how deep the review goes.
| Risk | Example changes | What the factory does |
|---|---|---|
| Low | Copy, styles, interface tweaks, documentation | Light human review; automatic merge only if the client authorizes it |
| Medium | Bug fixes, well-scoped features | Pull request reviewed by a person |
| High | Database, security, payments, core business logic | Mandatory human approval and controlled deployment |
SISCON’s position: mandatory human review
- It is our method. Just as in Agentic Software Development: a person reviews and merges every change; agents do not decide on their own what goes to production.
- Rules in code. Risk classification is not left to the agent alone.
- Optional autonomy. Automatic merge exists only for low-risk changes, if the client authorizes it and results support it.
Where it applies
Production lines you can set up
If something is done more than once a week, has a clear input and output and can be reviewed, it is a candidate.
Custom software
From specification to a verifiable MVP: agents code and test; our architects review and merge.
See the service →System modernization
Each migrated module is a task on the line, validated against the behavior of the original system.
See the service →Maintenance and support
A production bug enters the line and comes out as a proposed, tested fix ready for approval, within the SLA.
See the service →Business-area requests
Marketing or sales ask for a change by chat; the factory decides whether it needs technical approval.
With other SISCON lines
Method and service
IA Factory and Agentic Software Development
Agentic Software Development
The method SISCON builds with: specification before code, one test per clause and mandatory human review.
See the method →IA Factory
The service that sets up and runs the complete production line with that method, in your repository and under your rules.
Where it runs
In the cloud, hybrid or inside your network
The production line is the same; what changes is where the models live and, with that, what leaves your network.
In the cloud
Commercial models via API.
- Advantage
- Greater model capability and immediate start.
- To consider
- Code and context travel to a provider.
- Who it is for
- Code without confidentiality restrictions.
Hybrid
Local models for sensitive work, cloud for the rest.
- Advantage
- Balance between capability and privacy.
- To consider
- Clear rules on what goes where.
- Who it is for
- Repositories with critical parts.
On-premise
On Local Node, Private Platform or Governed Sovereign AI.
- Advantage
- Nothing leaves your network; logs under your control.
- To consider
- Quality with local models is measured first.
- Who it is for
- Regulated sectors and proprietary code.
Risks and controls
What can go wrong and how it is controlled
Every risk has a control on the line, not a promise.
| Risk | Control in the factory |
|---|---|
| A change breaks production | Risk gate, mandatory tests and a rollback plan for every deployment |
| Generated code with security flaws | Security reviewer on a different model, plus automated scanning |
| Loss of control over the architecture | Project memory and constitution every agent must check |
| Agents with too many permissions | Isolated environments, minimal and short-lived credentials |
| Token costs spike | A limit per task and a model suited to each kind of step |
| Dependence on one model provider | Interchangeable models per step, including local models |
| The team stops understanding its own code | Readable specifications, human review and living documentation |
How we deliver it
From a manual process to your first line in operation
We start with a single process, with full human review, and open up autonomy according to results.
- 01
Diagnostic
Candidate processes, a baseline of cycle times and risk level.
- 02
Harness
Memory, constitution, tools and evals in your repository.
- 03
First line
A factory for one process, with every task reviewed by a person.
- 04
Gradual autonomy
The risk gate opens as results support it, and only with your authorization.
- 05
Operation
KPIs, new lines and continuous improvement.
What the market is doing
Three published cases, one pattern
Engineering companies already work this way and have documented it publicly during 2026.
Stripe
pull requests merged per week, produced by its agents and reviewed by people.
Source: stripe.dev · February 2026
OpenAI
lines of code in an internal beta product, with no hand-written code. They call it harness engineering.
Source: openai.com · February 2026
StrongDM
human code reviews in its factory: it replaces review with scenario-based validation. SISCON does not follow that model: we keep human review.
Figures published by each company; they are not SISCON results. The common pattern: deterministic steps that cannot be skipped, agents in isolated environments and automated validation.
FAQ
Frequently asked questions
Does IA Factory replace my development team?
No. It changes their work: people specify, review and approve, and the factory handles the repeatable steps. A person merges every change.
Can the factory merge changes without human review?
Only as an option for low-risk changes —copy, styles, documentation— and only if you authorize it and results support it. Medium- and high-risk changes always go through a person.
Which processes are good candidates?
Those done more than once a week, with a clear input and output, that can be reviewed: bug fixes, well-scoped features, module migration, interface tweaks or documentation.
Does it work with local models, inside my network?
Yes, on any of our three on-premise AI architectures. With local models, scope is committed after measuring their quality with evals on your own code.
How is it different from Agentic Software Development?
Agentic Software Development is the method we build with: specification before code, one test per clause and mandatory human review. IA Factory is the service that sets up and runs the complete production line with that method.
How do you measure whether it works?
With KPIs defined in the diagnostic: cycle time, tasks resolved without intervention, defects reaching production and cost per task. We do not promise figures before measuring your baseline.
Next step
Start with a single process
A free discovery session to choose the candidate process, review your repository and define how your first line would be measured.