Agentic Software Engineering

Agentic software engineering is the practice of building software with AI agents as active participants in the development process. Unlike AI-assisted coding where the developer writes code with AI suggestions, agentic engineering shifts the developer's role toward specification, supervision, evaluation, and governance. The developer specifies what to build (detailed specifications), the agent plans and executes (writing code, running tests, creating PRs), the developer supervises (reviewing agent output, providing feedback), evaluates (checking quality, safety, and compliance), and governs (managing agent permissions, audit trails, and lifecycle). Key concepts include: software agents (autonomous AI systems that can plan, reason, and act), planning (deciding what steps to take), reasoning (understanding and making decisions), tool use (calling external functions), autonomous execution (working independently), agent workflows (multi-step processes), multi-agent systems (coordinated agents), agent delegation (assigning tasks to agents), human-in-the-loop (human approval at checkpoints), human-on-the-loop (human monitors but does not intervene), agent governance (managing permissions and behavior), agent memory (persisting context), agent state (tracking progress), agent observability (monitoring behavior), agent evaluation (measuring quality), agent security (preventing harm), and agent lifecycle (from creation to retirement). Current research is examining the transition toward specification, verification, and governance rather than simply accepting generated code. This is an important emerging engineering concept. This topic covers the complete landscape of agentic software engineering from theory to practice.

By 2026, agentic software engineering has emerged as a significant shift in how software is built. The developer's role is evolving from writing code to specifying, supervising, and governing AI agents. This shift is driven by the increasing capability of AI agents: they can understand specifications, write code, run tests, and create PRs. However, agents are not yet reliable enough for fully autonomous development. The key insight is that agentic engineering is about human-agent collaboration: the human provides specification and oversight, the agent provides execution capability. Enterprises that adopt agentic engineering with proper governance benefit from productivity gains while managing risks. The research community is actively exploring this transition, and it should be treated as an emerging concept rather than an established standard.

Enterprise Relevance: Agentic software engineering represents the next evolution of development. Understanding how to specify, supervise, and govern AI agents is essential for engineering leaders.

• Understand the shift from coding to specification and supervision
• Design effective specifications for AI agents
• Implement human-in-the-loop and human-on-the-loop patterns
• Design agent governance and permission systems
• Implement agent observability and evaluation
• Design multi-agent software engineering systems
• Manage agent memory and state
• Implement agent security controls
• Design agent lifecycle management
• Evaluate and compare agentic engineering approaches
• Understand current research and emerging standards
• Implement enterprise agentic engineering governance

Traditional software engineering: developers write code. AI-assisted coding: developers write code with AI suggestions. Agentic software engineering: developers specify what to build, agents write the code, developers supervise and govern. This shift changes the developer's role from creator to director. The key skills shift from coding to specification (writing clear, complete specifications), supervision (reviewing agent output), evaluation (checking quality), and governance (managing permissions and lifecycle).

Human-in-the-loop: the agent pauses for human approval at critical points. The human is actively involved in decision-making. Human-on-the-loop: the human monitors the agent but does not actively intervene unless something goes wrong. The human is a supervisor, not a participant. The choice depends on risk: human-in-the-loop for high-risk tasks, human-on-the-loop for lower-risk tasks with monitoring.

Agent governance manages what agents can do: permissions (what tools and actions), boundaries (what tasks), approval (when humans must approve), audit (logging all actions), and lifecycle (creation, deployment, retirement). Implementation: least privilege (only necessary permissions), permission scoping (limit per task), human approval for high-impact, audit trails for all actions, and regular permission review.

Agent memory persists context: short-term (current task), long-term (past tasks and preferences), and shared (knowledge accessible to all agents). Agent state tracks progress: what steps are done, what remains, what results were obtained. Agent observability monitors behavior: what the agent did, why, and what resulted. These are essential for debugging, evaluation, and governance.

Agentic software engineering architecture consists of the specification layer, agent layer, supervision layer, evaluation layer, governance layer, and observability layer. The architecture enables human-agent collaboration with proper oversight.

Specification-driven agentic engineering shifts effort from coding to specification. The developer writes detailed specifications: what to build, inputs, outputs, edge cases, constraints. The agent uses the specification to plan and execute. This approach works best when specifications are clear and complete. The challenge is that writing good specifications is a skill that takes time to develop. Current research is exploring how to make specifications more effective and how to handle ambiguity.

Multi-agent systems use multiple specialized agents: a specification agent, a coding agent, a testing agent, a review agent. Each agent focuses on its specialty. The agents collaborate: the spec agent writes specs, the coding agent implements, the testing agent tests, the review agent reviews. This can produce higher quality than a single agent but requires coordination. Frameworks like CrewAI and AutoGen support multi-agent systems.

Agent lifecycle management covers the complete life of an agent: creation (define purpose and permissions), deployment (put into production), monitoring (track behavior and quality), evaluation (assess effectiveness), upgrade (improve capabilities), and retirement (safely remove). Lifecycle management is essential for enterprise agents because agents are not static: they need updates, their quality may drift, and they eventually need to be retired.

• GCCs implement agentic engineering for enterprise development with governance.
• Shared Services organizations use agents for routine development tasks.
• Enterprise Engineering teams build agent platforms with lifecycle management.
• Product Engineering teams use agents for feature development.
• Digital Transformation initiatives adopt agentic engineering for modernization.
• AI Centers of Excellence define agentic engineering standards.
• IT Operations teams use agents for automation and tooling.
• Application Modernization programs use agents for code migration.

• LangGraph Documentation:Graph-based agent orchestration framework.
• CrewAI Documentation:Multi-agent framework documentation.
• AutoGen Documentation:Microsoft multi-agent framework.
• OpenHands Documentation:Open-source AI coding agent.
• Anthropic Research on Agents:Research on AI agent behavior and safety.
• NIST AI Risk Management Framework:AI risk management for agents.
• OWASP AI Security:AI security guidance for agents.
• Academic Research on Agentic Systems:Research papers on agentic software engineering.