From the makers of the Great International Developer Summit (GIDS), GAINS is an engineering-first summit focused on focused on software engineering in the age of AI.
đź“Ť Bengaluru, India
📅 09–10 December 2026
⏳ Submission Deadline: 15th July 2026
The GAINS Editorial Mandate
For most of the history of software engineering, we have built systems whose behavior was ultimately determined by code written by humans. While those systems often became extraordinarily complex, engineers could generally trace behavior back to explicit logic, reason about failure modes, and establish confidence through testing, observability, and operational controls.
That assumption is beginning to change.
Modern software increasingly retrieves information dynamically, reasons over context, generates plans, invokes tools, coordinates workflows, and takes actions whose outcomes cannot always be fully predicted in advance. Intelligence is becoming part of the runtime itself.
As a result, many of the most important challenges facing engineering teams today are no longer questions of model capability. They are questions of systems design, operational control, reliability, governance, evaluation, supervision, security, and scale.
How do we evaluate systems whose behavior changes with context? How do we supervise software that can act autonomously? How do we debug failures that cannot always be reproduced? How do we establish confidence in systems that are probabilistic rather than deterministic? How should software engineering evolve when intelligence becomes a first-class component of the software stack?
These are engineering questions. GAINS exists to explore them.
What is GAINS?
Great International AI Native Summit (GAINS) is an engineering-first summit focused on software engineering in the age of AI.
From architecture and software development through deployment, operations, governance, reliability, and scale, GAINS explores the engineering challenges that emerge when intelligence becomes part of software systems.
In the context of GAINS, the term AI-native extends beyond frontier models, autonomous agents, or greenfield AI products. We use it to describe software systems in which intelligence participates in execution, whether through retrieval, reasoning, recommendation, automation, decision support, code generation, workflow orchestration, or autonomous action. Increasingly, these capabilities are appearing not only in new products, but throughout existing software systems, enterprise platforms, developer workflows, and operational infrastructure.
We are interested in the systems surrounding intelligence as much as intelligence itself. Applications, agents, developer workflows, evaluation systems, observability platforms, infrastructure, security, governance, and operational control all become increasingly important as software incorporates probabilistic behavior.
The result is a conference that sits at the intersection of software engineering, distributed systems, platform engineering, AI infrastructure, operational reliability, and enterprise-scale software delivery.
Our focus begins where many AI conversations end. Not at the prototype. Not at the demo. Not at the proof of concept. But at the point where intelligent systems begin interacting with production infrastructure, enterprise workflows, governance requirements, customers, developers, operational constraints, and real-world consequences.
Who Should Submit?
GAINS is designed for practitioners building, operating, scaling, supervising, securing, evaluating, or governing software systems that incorporate intelligence.
This includes teams working on AI-powered applications, agentic systems, developer tooling, coding assistants, enterprise modernization initiatives, recommendation engines, search platforms, retrieval systems, workflow automation platforms, infrastructure services, observability systems, governance frameworks, and software delivery platforms.
The Questions We Care About
The strongest GAINS talks are usually built around a real engineering question rather than a technology, framework, or product. They often begin with a challenge that emerged unexpectedly, an assumption that turned out to be wrong, or a problem that became visible only after a system encountered the realities of production.
As intelligence becomes part of software systems, engineering teams are increasingly being asked to solve questions such as:
- How do we evaluate systems whose behavior evolves over time?
- What happens when software begins making decisions rather than simply executing instructions?
- How should we supervise autonomous execution?
- How do we establish operational boundaries for systems that can retrieve information, invoke tools, and take actions?
- What new forms of observability become necessary when traditional debugging techniques stop being sufficient?
- How do we govern systems whose behavior is influenced by prompts, context, retrieval pipelines, and model updates?
- How should organizations think about reliability when outputs are probabilistic rather than deterministic?
- What changes when software generation becomes abundant but engineering judgment remains scarce?
- How does software engineering itself evolve when coding agents become active participants in the development process?
These questions sit at the intersection of software engineering, platform engineering, distributed systems, infrastructure, security, governance, operations, and developer productivity. They are rarely solved by a single tool or framework and often require new ways of thinking about how software is designed, built, deployed, observed, and controlled.
These are the kinds of conversations we want to have at GAINS.
Focus Areas
The focus areas below are not technology categories.
They represent recurring engineering challenges that emerge when intelligence becomes part of software systems, software products, software delivery, and operational environments.
Every accepted session is classified into one primary focus area and may optionally span additional secondary areas.
AI-Native Applications & Product Systems
What are we building?
Intelligence is increasingly becoming part of products, services, enterprise applications, customer experiences, and internal platforms. We are interested in how software systems incorporate reasoning, retrieval, decision-making, and adaptive behavior while continuing to meet the expectations of reliability, usability, performance, and operational maintainability.Intelligence is increasingly becoming part of products, services, enterprise applications, customer experiences, and internal platforms. We are interested in how software systems incorporate reasoning, retrieval, decision-making, and adaptive behavior while continuing to meet the expectations of reliability, usability, performance, and operational maintainability.
Key themes include:
- Backend APIs and workflows powering AI-native applications
- Frontend patterns for human review, approval, correction, and escalation
- Retrieval-augmented systems in production
- Stateful probabilistic workflows
- Enterprise application patterns for systems that reason, decide, or act
- Human-facing product experiences shaped by intelligent behavior
- Integration of AI-native capabilities into existing software estates
Agents, Context & Execution
How do intelligent systems behave?
As software becomes capable of planning, coordinating, communicating, retrieving information, invoking tools, and acting across workflows, new questions emerge around control, supervision, reliability, and execution boundaries.
Key themes include:
- Single-agent and multi-agent orchestration
- Agent communication patterns and coordination models
- Context lifecycle management
- Memory architectures and tool execution
- Planning and reasoning under resource, latency, and cost constraints
- Workflow orchestration across agents, humans, tools, and systems
- Failure containment strategies for autonomous and semi-autonomous systems
AI-Native Software Development
How do we build these systems?
Software engineering itself is changing. Coding assistants, software agents, specification-driven workflows, AI-assisted testing, automated refactoring, and agentic development pipelines are reshaping how software is designed, implemented, reviewed, tested, and maintained.
Key themes include:
- Coding agents and software engineering agents
- AI-native software delivery workflows
- Specification-driven development
- Human-AI collaboration patterns for software teams
- AI-assisted architecture and design workflows
- AI-assisted testing, refactoring, modernization, and migration
- Agentic software delivery pipelines
- Context management for engineering workflows
- Engineering practices for AI-assisted development
- Supervision, review, and governance of AI-generated code
- Multi-stage software generation workflows for non-trivial applications
Production AI Systems
How do we know they are working?
Many of the hardest engineering challenges only emerge after deployment. How do we measure quality? Detect regressions? Evaluate behavior? Debug failures? Monitor performance? Establish confidence? Improve systems over time?
Key themes include:
- Evaluation systems and feedback loops
- Online versus offline evaluation mismatches
- Regression detection after model, prompt, tool, or retrieval changes
- Hallucination containment and quality degradation detection
- Runtime observability and introspection
- Debugging workflows for probabilistic system behavior
- Operational lessons from production AI failures
⚙️ Infrastructure, Platforms & Scale
How do we support intelligent systems reliably?
Every intelligent system eventually encounters the realities of throughput, latency, utilization, cost, reliability, and operational complexity.
Key themes include:
- High-throughput model serving and latency reduction
- GPU / TPU utilization and scheduling
- Caching, batching, routing, and fallback strategies
- FinOps cost-performance trade-offs
- Infrastructure reliability under probabilistic load
- Scaling retrieval, embedding, and context systems
- Platform engineering for AI-native systems
Trust, Security & Governance
How do we keep them inside operational boundaries?
As software gains greater autonomy, questions of accountability, control, security, auditability, and governance become increasingly important.
Key themes include:
- Prompt injection and adversarial behavior
- Data access boundaries and permission models
- Deterministic circuit breakers for agent permissions
- Auditability, traceability, and immutable logging
- Governance systems for AI-native organizations
- Human escalation and supervision architectures
- Operational control over tool use, code execution, and autonomous actions
Note: Sessions across all tiers and focus areas are highly curated, and many speakers are directly invited by the GAINS programme committee.
Audience Tiers
Every accepted session is classified into one of two audience tiers.
Tier A: Foundations
Engineering Judgment for the Age of AI
This tier is designed for experienced software engineers, architects, technical leads, platform engineers, engineering managers, and practitioners who are adapting established software engineering principles to environments where intelligence increasingly participates in system behavior.
These talks focus on helping attendees understand how software architecture, application design, developer workflows, software delivery, operational practices, and engineering decision-making are evolving.
Typical attendees include:
- Software Engineer with prior production development experience
- Senior Software Engineer (SDE-2 / SDE-3)
- Tech Lead
- Senior Backend Engineer
- Data Infrastructure Engineer
- Search & Recommendation Engineer
- Developer Productivity Engineer
- Platform Engineer
- Engineering Manager
Tier B: Production Systems
Operational Scale, Reliability & Control
This tier is designed for engineers responsible for operating, supervising, evaluating, securing, governing, and scaling intelligent systems under real-world constraints.
These talks focus on infrastructure, observability, reliability, evaluation, governance, operational control, security, and large-scale production environments.
Typical attendees include:
- Principal AI / ML Engineer
- Staff / Senior Staff Engineer
- GenAI Infrastructure Lead
- MLOps Platform Architect
- Site Reliability Engineer (SRE)
- Performance Engineer
- Distributed Systems Architect
- Chief Architect
Absolute Stage Anti-Patterns
We aggressively screen all submissions. Your proposal is unlikely to be accepted if it contains any of the following:
The Conceptual Pitch
Generic commentary on how “AI is changing the world,” macro-economic productivity narratives, or high-level futurism without engineering depth.
The Basic Wrapper Demo
Sessions that simply install an open-source framework, paste an API key, wire together a shallow workflow, or demonstrate a boilerplate template.
The Workflow Illusion
Prompt-engineering tricks or superficial UI-level workflow gimmicks presented without deterministic evaluation, operational constraints, or systems reasoning.
The Vendor Pitch
Sessions primarily showcasing commercial product interfaces, proprietary enterprise platform features, benchmark marketing, or disguised sales narratives.
The Success Theater Talk
Highly polished “everything worked perfectly” stories that avoid discussing operational failures, debugging complexity, rollback scenarios, evaluation breakdowns, or system degradation.
Technical Execution & Session Primitives
GAINS primarily curates 60-minute Long Talks and 30-min short talks structured around deep architectural and systems delivery.
Recommended structure:
- 60 or 30 minutes of systems and architectural delivery.Â
- Q&A in hallway post session
Every session is expected to follow two core principles.
1. The 10-Minute Rule
Within the first 10 minutes of your session, you should show one or more of the following:
- real code
- trace logs
- execution graphs
- system flows
- configration schemas
- evaluation outputs
- terminal sessions
- infrastructure diagrams
- orchestration traces
- debugging artifacts
Extended introductions and company overviews are strongly discouraged. We strongly prefer operational visibility over slide-heavy abstraction.
2. The Failure Anchor
Every session must dedicate meaningful time to hard-earned engineering judgment over idealized success stories.
We expect speakers to explicitly discuss what failed, what scaled poorly, what became operationally dangerous, what produced misleading metrics, what broke under load, and which architectural assumptions, what generated unexpected behavior, what proved difficult to supervise, and what turned out to be incorrect in production.
Actionable Abstract Blueprinting
To submit a proposal, your abstract must be structured around production realities rather than marketing narratives.
You are required to explicitly answer the following questions inside the submission form.
The Target Tier
Is this Foundations (Systems Transition) or Advanced Production (Specialist Infrastructure)?
The System Friction Point
What concrete production bottleneck, anti-pattern, failure mode, or operational constraint does this talk address?
The Mechanics
What real systems artifacts will you show on screen within the first 10 minutes?
Examples include config schemas, telemetry traces, raw code paths, evaluation outputs, debugging workflows, or orchestration flows.
The “What Not To Do”
What common shortcut, brute-force hack, misleading metric, or operationally dangerous assumption will you explicitly warn the audience against?
Session Formats
The GAINS 2026 Call for Speakers is accepting the following formats. Using this form, you may submit up to 5 talk proposals.
- Long Talk: 60-minute presentation
- Short Talk: 30-minute presentation
For international speakers, we request that you submit only 60-minute session proposals. You are encouraged to submit multiple sessions. Each proposal is evaluated independently, and submitting more high-quality proposals can improve your chances of selection.
Speaker Logistics & Support
Selected International Speakers may receive:
- Travel support of up to US$ 2,000
- 2 nights of accommodation
- Full conference access
International speakers are expected to submit multiple 60-minute session proposals. If your employer or organization is able to cover or co-fund your travel, please indicate this in your submission so we can prioritize support for independent practitioners.
Selected Inter-state Speakers may receive:
- Travel and accommodation support of up to Rs. 20,000
- Full conference access
Selected Local Speakers will receive:
Additional Notes
- Speaker support is discretionary and not guaranteed upon acceptance.
- Acceptance decisions are based on the strength and relevance of the submission.
- All reimbursements will be processed post-event upon submission of valid bills and invoices.
- Reimbursements will be limited to the approved support caps stated above.
- If your participation is supported by your employer or organization, please indicate this in your submission.
- Only the primary speaker is eligible for speaker support unless explicitly approved otherwise.
- A maximum of one co-speaker is allowed per session.
- Approved co-speakers must purchase a valid conference pass.
- The organizers are not responsible for cancellation, rescheduling, or fare differences arising from changes to travel or accommodation bookings.
Join The Conversation
The transition from deterministic software systems to systems that incorporate probabilistic behavior is one of the most significant shifts our industry has experienced.
The models will change. The frameworks will change. The tools will change. The engineering questions will remain.
If your work has given you new insight into how intelligent systems are designed, built, evaluated, supervised, governed, scaled, secured, or operated, we would love to hear from you.
Help shape the inaugural edition of GAINS 2026.
Deadline to Submit: 15th July 2026