--- title: The Last Seat slug: the-last-seat canonical_url: https://blog.openfactoryai.com/the-last-seat published_at: 2026-07-14T21:00:00.289665+00:00 author: OpenFactoryAI tags: Global Capability Centers, Offshore Development Centers, software factory AI, offshoring economics, CTO strategy tldr: Global Capability Centers and Offshore Development Centers industrialized distributed software work by moving skilled teams, process, and ownership across borders. AI does not erase that achievement. It changes the economic unit. When agents can generate and execute work continuously, the scarce inputs become intent, environment access, verification, exception judgment, and accountable ownership. CTOs should compare assisted teams, delegated agent workflows, and autonomous factories by cost per verified outcome, not salary versus token price. key_takeaways: - GCC and ODC describe ownership and delivery structures, not one quality level. - The historical unit was dedicated human capacity: seats, rates, utilization, and person-months. - AI makes generated work abundant before it makes verified outcomes abundant. - Compare operating models with full task cost, delay, coordination, verification, rework, and failure loss. - The likely transition is not onshore versus offshore; it is seat-priced capacity versus outcome-priced, evidence-bearing automation. --- The last seat will not be empty. It will be mispriced. For decades, software capacity was purchased as people: employees, contractors, dedicated teams, billable seats, full-time equivalents, and person-months. Global Capability Centers and Offshore Development Centers made that capacity available across borders at extraordinary scale. AI changes the denominator. A model can generate more code than an organization can safely understand, integrate, and own. The scarce resource moves from production to proof. This is the rise and fall of GCCs and ODCs: not a forecast that the institutions vanish, but a claim that the seat loses its place as the default economic unit. ::figure{template=timeline caption="The unit of software capacity moves from labor location toward verified outcome" items="Onsite labor :: person at client | Offshore project :: remote task delivery | ODC :: dedicated vendor capacity | GCC :: captive global capability | AI-assisted team :: people produce with models | Delegated loop :: agents complete bounded work | Software factory :: verified outcomes under policy"} ## First, define the structures The terms are used inconsistently, so this article fixes a scope. **Global Capability Center (GCC):** a captive or global in-house center owned or controlled by the enterprise. It employs people who belong to the company or its group and can hold product, engineering, operations, data, finance, or research capability. **Offshore Development Center (ODC):** a persistent dedicated development unit in another country, commonly operated by a services vendor for a client under a contract. Some companies also use ODC for their own captive center. Here, ODC means the vendor-operated dedicated-team model so the ownership difference remains visible. **Outsourcing** transfers work to another company. **Offshoring** moves work across national borders. A GCC can be offshore without being outsourced. A vendor ODC can be both. These are governance choices, not quality labels. Either can produce excellent or poor software. A mature GCC may own global products. A vendor ODC may retain deep system knowledge for years. A badly designed captive center can still become a ticket queue. ::figure{template=compare caption="GCC and ODC differ mainly in ownership, incentives, and control" items="Enterprise team :: direct employment, local or distributed | GCC :: captive global unit, enterprise ownership | Vendor ODC :: dedicated external unit, contractual control | Project outsourcing :: external deliverable, variable continuity | Agent factory :: machine execution, enterprise policy and proof"} ## Why the model rose Software became tradable without shipping a physical product. Telecommunications moved source, specifications, builds, and results. Time-zone separation enabled follow-the-sun work. Firms could access large skilled labor pools and build repeatable delivery processes. India is one major evidence base, not the whole story. An academic history in the [Oxford Handbook of Offshoring and Global Employment](https://academic.oup.com/edited-volume/41253/chapter-abstract/350811851) describes India's rise as a major offshore ICT-services production center between 1985 and 2010. An [IMF country study](https://www.elibrary.imf.org/view/journals/002/2005/087/article-A002-en.xml) reports a historical shift in India from 62 percent onsite delivery in 1993-94 to offshoring becoming dominant by 2002-03 at about 58 percent of exports. These figures describe that period and source, not today's delivery mix. Current primary data shows scale without proving one exact “world's largest human software factory” superlative. Software Technology Parks of India's [2024-25 annual report](https://stpi.in/sites/default/files/annual-reports-documents/stpi_annual_report_2024_2025_eng.pdf) reports ₹10,69,270.59 crore of exports by STPI-registered IT/ITeS units in FY2024-25, up 13.35 percent from the prior year. That is about ₹10.69 trillion. The population is STPI-registered units, not all global software production. The Reserve Bank of India runs an annual [Computer Software and ITES Exports survey](https://systemhealth.rbi.org.in/Scripts/Pr_DataRelease.aspx_SectionID%3D364%26DateFilter%3DYear.html) covering activity, organization type, onsite and offsite nature, modes of supply, employment, and overseas affiliates. The statistical structure itself reveals how the industry was understood: firms, employees, locations, delivery modes, invoices, and exports. The model rose because it solved real constraints: - scarce local hiring capacity; - wage and location differences; - demand for continuous maintenance and operations; - need for dedicated institutional knowledge; - repeatable process and quality systems; - access to specialized technical domains; - round-the-clock support; - flexible scaling through vendors or captive hiring. Calling all of this “cheap labor” misses the organization built around it. ## The seat became the unit Capacity contracts commonly reduce a complex system to quantities that can be bought and governed: ```text number of people role and seniority mix monthly rate utilization location service level attrition and replacement ``` The client can compare a 50-seat ODC with a 100-seat one. The GCC can plan headcount, facilities, recruiting, and management layers. The services firm can build a pyramid of junior and senior labor and target utilization. The abstraction is practical. It is also lossy. Two teams with 100 seats do not have equal system knowledge, decision speed, integration burden, or verified output. Distributed-software research has documented why. A study based on 130 construction cycles across 34 offshore projects modelled coordination cost as a function of software complexity, integration, organization, and learning ([Ramasubbu, Mehra, and Mookerjee](https://aisel.aisnet.org/pacis2009/102/)). Research on [optimal coordination in distributed software development](https://journals.sagepub.com/doi/10.1111/poms.12408) describes the tradeoff between continuous coding and the disruptive work needed to integrate it. A study of 102 outsourcing relationships found task and location complexity influenced customer control and coordination cost ([Handley and Benton](https://www.sciencedirect.com/science/article/pii/S0272696312000897)). These studies do not say offshoring fails. They say labor rates do not contain the whole cost. ## The fall is a unit-economic transition AI can reduce the marginal cost of some production steps: - searching and explaining code; - generating and revising implementations; - creating tests and documentation; - running tools and interpreting logs; - translating patterns across languages; - performing repetitive maintenance; - exploring candidate migrations. But cheap generation creates a new queue: ```text intent -> candidates -> verification -> integration -> ownership ``` If candidate output grows tenfold while verification capacity stays fixed, work in process expands and lead time can worsen. The factory does not create value by maximizing generated code. It creates value by increasing terminal verified outcomes within cost, deadline, and risk limits. That breaks the clean link between headcount and capacity. A five-person team with a strong environment, agent runtime, tests, and decision rights may outperform a much larger ticket-taking unit on one task slice. The larger unit may still outperform it on ambiguous domains, stakeholder coordination, incident judgment, and organizational change. The fall is selective. It hits work whose value was closely tied to repeatable production hours before it hits work whose value is problem framing, authority, negotiation, novel architecture, or responsibility. ::figure{template=layers caption="AI compresses production first and exposes the remaining scarce layers" items="Accountable outcome :: business owner accepts consequence | Independent proof :: behavior, policy, security, operations | Integration :: dependencies, migration, rollout, rollback | Agent execution :: search, edit, test, revise, tools | Inference :: models, context, routing, tokens | Infrastructure :: compute, repositories, data, environments"} ## Four operating models, four cost structures ### 1. Human-led GCC or internal team People own intent, implementation, validation, and operation. AI may assist locally. Cost is primarily loaded labor plus platform, management, coordination, and delay. Best when work is ambiguous, high-consequence, politically coupled, or dependent on tacit company knowledge. ### 2. Vendor ODC A contracted dedicated team supplies persistent capacity. The client owns product direction and contract governance; operational knowledge crosses an organizational boundary. Best when continuity, flexible capacity, established vendor process, or access to a labor market is more valuable than direct employment. ### 3. Delegated agent workflow Humans define tasks and approve important effects. Agents execute bounded loops such as dependency updates, test repair, migrations in sandboxes, documentation synchronization, or incident triage. Best when tasks are repeatable, environments are instrumented, and verification is strong. ### 4. Autonomously managed software factory The system accepts goals, decomposes and executes work, allocates inference, reconciles effects, verifies outcomes, stops, and escalates exceptions under policy. Humans own objectives, authority, governance, and unresolved consequence. Best only for task slices where evidence shows stable verified outcomes, bounded exceptions, recoverability, and favorable economics. The models can coexist. A GCC can operate the factory. An ODC can supply domain experts and exception handling. A product team can delegate a narrow path while retaining human-led architecture. ## Never compare salary with token price The invalid comparison is: ```text one developer month costs X one million tokens costs Y therefore AI is X/Y times cheaper ``` A person-month includes discovery, context, decisions, communication, implementation, review, ownership, and exception handling. Tokens are one input to uncertain computation. Compare one verified outcome: ```text total outcome cost = loaded production labor + coordination and management + inference, tools, infrastructure + verification and review + rework + exception handling + expected failure loss + delay cost ``` Use the same denominator, scope, quality bar, and time window for every model. ## Worked model: 1,000 maintenance tasks Assume 1,000 comparable low-to-medium consequence maintenance tasks per month. All values are illustrative. They are not industry averages, customer data, or forecasts. | Input | Vendor ODC | GCC + AI assist | Delegated agents | Autonomous route | |---|---:|---:|---:|---:| | Direct run/labor cost | $180,000 | $155,000 | $42,000 | $28,000 | | Coordination/platform | $28,000 | $22,000 | $18,000 | $24,000 | | Verification/review | $32,000 | $35,000 | $54,000 | $48,000 | | Rework/failure loss | $20,000 | $17,000 | $28,000 | $38,000 | | Verified outcomes | 900 | 930 | 880 | 820 | ```text ODC total = $260,000; cost / verified = $288.89 GCC + assist total = $229,000; cost / verified = $246.24 Delegated total = $142,000; cost / verified = $161.36 Autonomous total = $138,000; cost / verified = $168.29 ``` The autonomous route has the lowest total spend and loses to delegated agents on cost per verified outcome because failure loss is higher and fewer outcomes pass. The model makes a pointed inference: removing people faster than verification improves can reduce value. ::figure{template=bar caption="Illustrative full cost per verified maintenance outcome" items="Vendor ODC :: 288.89 | GCC plus assist :: 246.24 | Delegated agents :: 161.36 | Autonomous route :: 168.29"} Now change the task mix. If 400 tasks have ambiguous requirements and autonomous success falls sharply, route them to humans. If 300 dependency updates have executable verifiers and a 97 percent agent success rate, automate them. One fleet-wide autonomy percentage hides both decisions. ## The provocative 1 / 15 / 84 model Consider an extreme future human-attention allocation: ```text 1% manual coding 15% steering goals, constraints, and exceptions 84% validation, evidence review, risk, and acceptance ``` This is a scenario, not a measured workforce forecast. It is intentionally provocative. If “validation” means humans manually inspect every generated line, the operating model fails. Production moved to machines while the bottleneck moved to people. The viable interpretation is layered validation: - machines perform deterministic tests, schemas, policy, static checks, simulation, and trace comparison; - independent models challenge evidence where their calibration is known; - humans spend scarce attention on ambiguous intent, novel failure, consequence, and final accountability; - sampled audits estimate failures that automatic verifiers miss. The goal is not to maximize 84 percent. It is to shrink manual validation while increasing independent proof. ::figure{template=compare caption="Illustrative human-attention scenario: production falls only if proof becomes machine-speed" items="Manual code 1% :: direct implementation by humans | Steering 15% :: goals, constraints, exceptions | Validation 84% :: evidence, risk, acceptance | Warning :: manual validation becomes the new factory floor"} ## The CTO's hardest decision is not build versus buy The decision is how much authority the system earns. ### Assist AI proposes; a person drives every transition. Choose when tasks are novel, environments are weak, consequences are high, or the team is still learning failure modes. ### Delegate A person assigns a bounded outcome; the agent loops through permitted actions and returns evidence. A person approves selected effect classes. Choose when task boundaries, tools, state, budgets, and verifiers are explicit. ### Autonomously manage The factory schedules, executes, verifies, reconciles, and commits within policy, escalating only exceptions. Choose by task slice only after measured shadow and canary evidence establishes: - stable on-time verified success; - low and bounded exception rate; - favorable cost per verified outcome; - idempotent or compensable effects; - traceable authority and artifacts; - fast rollback; - no hidden transfer of labor to reviewers or operators. ::figure{template=matrix caption="Authority should rise only when verification is strong and consequence is bounded" items="Assist :: weak verifier / any consequence | Delegate :: strong verifier / reversible effect | Autonomous :: strong proof / bounded consequence | Human-led :: ambiguous intent / high consequence | Shadow :: uncertain capability / no authority | Block :: irreversible effect / weak evidence"} ## What happens to GCCs and ODCs The simplistic forecast is replacement. The more defensible inference is recomposition. GCCs can gain strategic value because they combine enterprise identity, domain context, direct authority, and long-term ownership. Their headcount growth may decouple from output growth as they operate more agent capacity per person. ODCs can lose advantage where contracts monetize hours, seats, or pyramids while automation reduces required production labor. They can gain advantage if they price and prove outcomes, contribute proprietary domain environments, absorb exception variability, and share productivity transparently. Both can become worse if AI merely accelerates ticket volume. More generated change increases integration and review load without fixing ownership. The organizations that survive the unit shift will sell or own: - executable environments; - domain evidence and current system state; - reusable automation and agent loops; - verification assets; - operational receipts and traceability; - exception judgment; - accountable outcomes. The seat does not disappear. It stops being the product. ## Builder and buyer playbook 1. Segment the backlog by task repeatability, ambiguity, consequence, and verifier strength. 2. Measure the current GCC, ODC, or internal baseline at task level: lead time, loaded cost, review, rework, failure, and outcome. 3. Instrument AI assistance before claiming productivity. Look for labor transferred into validation. 4. Build delegated loops for narrow reversible tasks with explicit postconditions. 5. Compare cost per verified outcome, not tokens, commits, story points, seats, or salary. 6. Require vendors and internal centers to expose traceable automation, verifier results, and exception denominators. 7. Keep production authority separate from model and conversational consensus. 8. Expand autonomy by task slice through shadow, canary, audit, and rollback gates. 9. Renegotiate capacity contracts when machine throughput breaks the link between headcount and output. 10. Invest the saved production time in better intent, environments, proof, and system ownership. The rise of global software centers proved that work could move. The next era asks whether work can move without moving responsibility. That is where the last seat remains. ## References - [Software Technology Parks of India, Annual Report 2024-25](https://stpi.in/sites/default/files/annual-reports-documents/stpi_annual_report_2024_2025_eng.pdf). Primary report of exports by STPI-registered IT/ITeS units and the exact FY2024-25 figure used here. - [Reserve Bank of India, Computer Software and ITES Exports survey releases](https://systemhealth.rbi.org.in/Scripts/Pr_DataRelease.aspx_SectionID%3D364%26DateFilter%3DYear.html). Primary statistical series covering organization, delivery nature, employment, and modes of supply. - [Parthasarathy, “The Changing Character of Indian Offshore ICT Services Provision, 1985-2010,” Oxford Handbook chapter](https://academic.oup.com/edited-volume/41253/chapter-abstract/350811851). Academic history of India's offshore ICT-services production system. - [IMF, “India: Selected Issues,” 2005](https://www.elibrary.imf.org/view/journals/002/2005/087/article-A002-en.xml). Historical data on the movement from onsite to offshore delivery in India's software exports. - [Ramasubbu, Mehra, and Mookerjee, “Modeling Coordination in Offshore Software Development,” PACIS 2009](https://aisel.aisnet.org/pacis2009/102/). Empirical basis from 130 construction cycles across 34 offshore projects. - [Xia, Dawande, and Mookerjee, “Optimal Coordination in Distributed Software Development,” Production and Operations Management, 2016](https://journals.sagepub.com/doi/10.1111/poms.12408). Models the coding versus integration coordination tradeoff. - [Handley and Benton, “The Influence of Task- and Location-specific Complexity on the Control and Coordination Costs in Global Outsourcing Relationships,” Journal of Operations Management, 2013](https://www.sciencedirect.com/science/article/pii/S0272696312000897). Dyadic evidence from 102 outsourcing relationships. - [NASSCOM, Annual Strategic Review 2025 press release](https://www.nasscom.in/sites/default/files/media_pdf/Nasscom%20SR%20Press%20release.pdf). Industry-body evidence that GCC and engineering R&D were identified as growth segments; used as context, not neutral market forecasting. ## FAQ ### What is the difference between a GCC and an ODC? A GCC is generally a captive global in-house center owned or controlled by the enterprise. In this article, an ODC is a persistent dedicated offshore development unit operated by a vendor for a client. Industry usage varies, so contracts and ownership matter more than the label. ### Will AI replace offshore software development centers? No universal disappearance claim is supported. AI can reduce labor required for repeatable production while increasing demand for environments, verification, integration, exception handling, and ownership. Centers will be affected differently by task mix and commercial model. ### How should a CTO compare offshoring with an AI software factory? Compare the same verified task outcome, including loaded labor, coordination, inference, tools, infrastructure, review, rework, exceptions, delay, and expected failure loss. Do not compare salary with token price. ### When should software work be delegated to AI agents? Delegate bounded tasks with explicit state, typed tools, reversible effects, strong verifiers, budgets, traces, and clear escalation. Begin in shadow mode and expand by task slice after stable evidence. ### What does 1 percent coding and 99 percent control mean? It is a deliberately extreme scenario, not a workforce forecast. It tests whether machine production can be matched by machine-speed verification, leaving human attention for steering, ambiguity, consequence, and exceptions. ### What happens to IT services contracts when AI raises productivity? Seat, hour, and utilization pricing can misalign incentives when output decouples from headcount. Outcome pricing is viable only with shared definitions, independent verification, exception rules, change control, and transparent risk allocation. ## Test yourself ### 1. What is the article's meaning of the fall of GCCs and ODCs? - [ ] Every center closes - [x] The seat loses primacy as the unit of software capacity - [ ] Offshoring becomes illegal - [ ] Developers stop working **Explanation:** The claim concerns the economic unit and operating model, not an unsupported disappearance forecast. ### 2. Which statement correctly distinguishes GCC from ODC in this article? - [x] GCC is captive; ODC is a vendor-operated dedicated unit - [ ] GCC is always onsite - [ ] ODC has no developers - [ ] They are quality ratings **Explanation:** The chosen scope keeps ownership and contractual control visible, while acknowledging industry terminology varies. ### 3. Why is salary versus token price invalid? - [ ] Tokens have no price - [x] They represent different bundles of work, ownership, verification, and risk - [ ] Salaries are secret - [ ] Models never write code **Explanation:** The valid comparison uses the same terminal verified outcome and all costs. ### 4. Why did delegated agents beat the autonomous route in the illustrative model? - [ ] They had higher direct cost - [x] Higher verified outcomes and lower failure loss produced lower cost per verified outcome - [ ] They used no verification - [ ] Autonomy had no outputs **Explanation:** Lowest total spend did not equal best outcome economics. ### 5. What earns autonomous authority? - [ ] A confident demo - [x] Stable slice-level outcome, cost, exception, recoverability, trace, and rollback evidence - [ ] A large token budget - [ ] Majority vote **Explanation:** Authority expands through measured evidence and bounded consequence.