Latest / AI Builds It: Easy Coding Tools / Autonomous Coding Agents in June 2026: A Comprehensive Landscape and Taxonomy

Transcript

Autonomous Coding Agents in June 2026: A Comprehensive Landscape and Taxonomy · AI Builds It: Easy Coding Tools

• 0:00
  SPEAKER_00: Autonomous Coding Agents, Landscape and Taxonomy, June 2026.
• 0:06
  SPEAKER_00: Introduction.
• 0:07
  SPEAKER_00: AI-powered coding agents have rapidly transformed software development.
• 0:12
  SPEAKER_00: No longer just auto-complete helpers, they now execute complex tasks, planning, editing, testing code, and more, on behalf of developers.
• 0:21
  SPEAKER_00: The shift is dramatic.
• 0:23
  SPEAKER_00: As UiPath CEO notes, AI can write code.
• 0:27
  SPEAKER_00: The question is what happens after the code is written?
• 0:30
  SPEAKER_00: In fact, by mid-2026, an estimated 84% of developers use or plan to use AI coding assistance.
• 0:39
  SPEAKER_00: Today's agents range from simple code completion tools to fully autonomous collaborators that plan multi-step changes, run builds, tests, and create PRs.
• 0:50
  SPEAKER_00: This article maps the rich 2026 ecosystem, commercial SaaS and self-hosted tools, open frameworks, and enterprise platforms.
• 0:59
  SPEAKER_00: We classify agents by their autonomy level, supported languages, integration points, safety governance features, and deployment model.
• 1:07
  SPEAKER_00: We also trace the research lineages from transformers and chain of thought to memory-enhanced agents and give a timeline of key releases.
• 1:16
  SPEAKER_00: Finally, for newcomers, we outline how to start using these tools and the first steps in building an AI-assisted development workflow.
• 1:24
  SPEAKER_00: Commercial platforms.
• 1:26
  SPEAKER_00: Leading AI companies have released coding agent products tailored to various users.
• 1:31
  SPEAKER_00: GitHub Copilot, OpenAI Microsoft.
• 1:35
  SPEAKER_00: Launched 2021, Copilot uses the Codex model to suggest code completions in IDEs.
• 1:42
  SPEAKER_00: It became the poster child for AI parent programmers, integrating into VS Code, JetBrains, and other editors.
• 1:49
  SPEAKER_00: OpenAI's Codex fine-tuned on public code powered Copilot, bringing AI suggestions mainstream in IDEs.
• 1:57
  SPEAKER_00: Copilot supports dozens of languages, Python, JavaScript, TypeScript, Java, C, etc., and is offered in free, open source, and paid plans, including enterprise licensing.
• 2:08
  SPEAKER_00: Amazon Code Whisperer.
• 2:10
  SPEAKER_00: Introduced in 2022, Code Whisperer is AWS's co-pilot competitor.
• 2:15
  SPEAKER_00: By 2023, it went generally available, with free and professional TUs.
• 2:20
  SPEAKER_00: It supports a wide range of languages: Python, Java, JavaScript, TypeScript, C, Plus Go, Rust, Kotlin, Scala, Ruby, PHP, SQL, C, C, Shell, etc.
• 2:32
  SPEAKER_00: Code Whisperer runs as a cloud service integrated into AWS Toolkits and Tools, and offers enterprise administration features, license policy management in its pro tier.
• 2:43
  SPEAKER_00: Anthropic Claude Code, Claude Co-Work.
• 2:46
  SPEAKER_00: Anthropic pioneered a terminal-based agent, Claude Code, launched Feb 2025.
• 2:52
  SPEAKER_00: It can access a user's files, spawn sub-agents, and execute multi-step workflows, e.g., DNA analysis.
• 3:00
  SPEAKER_00: Time reports it even autonomously grew a tomato plant via genetic data.
• 3:05
  SPEAKER_00: Claude Code emphasizes autonomy plus safety.
• 3:08
  SPEAKER_00: It uses explicit planning and an approval loop before destructive changes.
• 3:13
  SPEAKER_00: In Jan 2026, Anthropic expanded its agent line with Claude Co-Work, a more user-friendly interface for the same capabilities.
• 3:22
  SPEAKER_00: Claude Code supports coding in major languages, Python, JS, etc., and benchmarking shows it excels at software tasks.
• 3:32
  SPEAKER_00: Cursor, AnySphere.
• 3:34
  SPEAKER_00: Cursor is a VS Code-based AI code editor built on advanced LLMs.
• 3:39
  SPEAKER_00: In 2025, its startup AnySphere raised$900 million on a$9.9 billion valuation.
• 3:47
  SPEAKER_00: Cursor offers inline completions, a chat agent tab, and tools for automating tasks, like generating shell commands by natural language prompt.
• 3:56
  SPEAKER_00: It works as a standalone editor, forked from VS Code, and supports content authoring in 50 plus programming languages, plus chat-driven operations.
• 4:06
  SPEAKER_00: Google Gemini Code Assist.
• 4:08
  SPEAKER_00: Google now offers Gemini Code Assist, standard enterprise, and the open source Gemini CLI.
• 4:15
  SPEAKER_00: These use Google's advanced Gemini models with up to 1 million token context.
• 4:20
  SPEAKER_00: For example, Gemini CLI.
• 4:22
  SPEAKER_00: Open source lets you run AI coding agents in any terminal.
• 4:26
  SPEAKER_00: It comes with built-in tools, web search, file system, and shell access, and can use Google's cloud LLMs or local models.
• 4:34
  SPEAKER_00: Its workspace can read-write your code files and run commands under your control.
• 4:39
  SPEAKER_00: The CLI is free with a Google account, and enterprise versions add more security and integration.
• 4:46
  SPEAKER_00: IBM WatsonX Code Assistant.
• 4:48
  SPEAKER_00: IBM markets WatsonX Code Assistant for Enterprise Software Teams.
• 4:53
  SPEAKER_00: In 2024-25, it introduced services specifically for planning and upgrading Java applications.
• 5:00
  SPEAKER_00: The product is enterprise ready with governance, compliance, and works across languages, notably Java, to modernize legacy code.
• 5:09
  SPEAKER_00: IBM claims deep integration with IBM workflows, e.g., DevOps Jenkins, and focuses on security and scale.
• 5:16
  SPEAKER_00: Its GitHub repo notes support for languages like Go, C, C, Java, JavaScript, Python, TypeScript, etc.
• 5:25
  SPEAKER_00: Others.
• 5:25
  SPEAKER_00: There are many SaaS offerings and early stage platforms.
• 5:29
  SPEAKER_00: OpenAI's ChatGPT Copilot for Coding, Microsoft's Copilot for Business and Copilot Chat, Google's barred code, open source APIs, OpenRouter, etc., and specialized tools from startups, e.g.
• 5:43
  SPEAKER_00: AMP code, Jellyfish, etc.
• 5:45
  SPEAKER_00: Many major IDEs, VS Code JetBrains, now include multiple agent options, e.g., Juni and Cloud Agent in JetBrains.
• 5:54
  SPEAKER_00: Open source frameworks.
• 5:55
  SPEAKER_00: Many open source projects let developers build or run coding agents themselves.
• 6:00
  SPEAKER_00: Key examples include OpenHands.
• 6:03
  SPEAKER_00: This Python-based SDK and accompanying CLI GUI lets you define agent skills in code and run them locally.
• 6:10
  SPEAKER_00: OpenHands provides a CLI agent that you bootstrap by giving it natural language tasks.
• 6:15
  SPEAKER_00: It can use any LLM you choose, OpenAI, Anthropic, or a local model via OLAMA VLLM.
• 6:23
  SPEAKER_00: The CLI follows an IDE-like workflow and can automate branching, PR creation, testing, etc.
• 6:30
  SPEAKER_00: OpenHands V1 6 even added a planning mode to draft a plan before execution, avoiding endless loops.
• 6:39
  SPEAKER_00: It supports dozens of languages via any LLM and can run entirely on your machine or scale in the cloud.
• 6:47
  SPEAKER_00: OpenClaw, originally a personal assistant, OpenClaw has an AI agent incarnation that interfaces via chat apps.
• 6:55
  SPEAKER_00: It's fully open source and self-hosted, no vendor lock-in.
• 7:00
  SPEAKER_00: OpenClaw lets you add skills, markdown defined actions, and connects to 50 plus channels, Slack, Discord, WhatsApp, etc.
• 7:09
  SPEAKER_00: It is model agnostic.
• 7:11
  SPEAKER_00: It can plug into Claude, GPT, Gemini, local LLMs, etc.
• 7:17
  SPEAKER_00: OpenClaw emphasizes security.
• 7:19
  SPEAKER_00: Every skill runs in an isolated sandbox with fine-grained permissions, and you must explicitly approve what each agent can access.
• 7:28
  SPEAKER_00: Though general purpose, OpenClaw's pipeline can be used for coding tasks as well.
• 7:34
  SPEAKER_00: Goose.
• 7:34
  SPEAKER_00: Goose is a multi-platform agent, Rust-based desktop app and CLI for any task, including coding.
• 7:42
  SPEAKER_00: It supports 15 plus LLM providers, Anthropic, OpenAI, Google, Olama, etc.
• 7:49
  SPEAKER_00: Usually run on your machine.
• 7:51
  SPEAKER_00: Goose uses the Model Context Protocol MCP to integrate with tools.
• 7:55
  SPEAKER_00: There are 70 plus extensions documented.
• 7:58
  SPEAKER_00: For coding, Goose offers file system and terminal tools via MCP and can orchestrate multi-step fixes.
• 8:05
  SPEAKER_00: Like OpenHands, it's self-hosted and open source, MIT license.
• 8:10
  SPEAKER_00: Goose is lighter weight than some alternatives, but emphasizes extensibility via MCP.
• 8:16
  SPEAKER_00: ADER.
• 8:17
  SPEAKER_00: ADER 44K GitHub Stars 6.8M installs is a terminal-centric AI pair programmer.
• 8:24
  SPEAKER_00: It works with either cloud or local models and maps your entire code base so the agent has project-wide context.
• 8:32
  SPEAKER_00: ADER supports 100 plus languages Python, JavaScript, Rust, Ruby, Go, C C, PHP, etc.
• 8:40
  SPEAKER_00: Crucially, ADER autocommits all changes.
• 8:43
  SPEAKER_00: It uses Git to record each AI edit with a meaningful commit message.
• 8:47
  SPEAKER_00: It also integrates into IDEs, VS Code, JetBrains, so you can annotate code and have ADER enact changes.
• 8:55
  SPEAKER_00: In short, ADER is for developers who want the agent under their command.
• 8:59
  SPEAKER_00: They prompt changes and the tool applies them transparently via Git.
• 9:03
  SPEAKER_00: IDE extensions, Kline, continue, etc.
• 9:07
  SPEAKER_00: Some open agents live entirely inside an editor.
• 9:10
  SPEAKER_00: For example, Kline is an open source VS Code extension, describing itself as an autonomous coding agent, capable of creating, editing files, executing commands, and browsing the web, all with user permission.
• 9:23
  SPEAKER_00: It has planning approval loops too.
• 9:26
  SPEAKER_00: Continue is another VS Code agent assistant with multiple modes.
• 9:30
  SPEAKER_00: Chat, inline autocomplete, extend this code, edits.
• 9:34
  SPEAKER_00: These agents embed in the IDE and have GUI workflows but can operate semi-autonomously on tasks.
• 9:40
  SPEAKER_00: Gemini CLI, Google.
• 9:43
  SPEAKER_00: Google's Gemini 3.5 Plus models offer a CLI agent, which is open source.
• 9:49
  SPEAKER_00: The Gemini CLI tool gives developers a terminal-based agent that can invoke Google search and stack-wide file operations.
• 9:58
  SPEAKER_00: It can use Google's Cloud Model Pool, free tier available, or run local models.
• 10:03
  SPEAKER_00: It supports large context, 1 million tokens, for understanding entire repos.
• 10:09
  SPEAKER_00: It's a bridge between self-host and SaaS.
• 10:12
  SPEAKER_00: The code is local, but relies on Google's LLM service unless run with a downloaded model.
• 10:18
  SPEAKER_00: Overall, open source agents share many traits: local deployment, flexible model choice, multilanguage support, and integration with standard development tools, Git shells.
• 10:30
  SPEAKER_00: They differ in style.
• 10:31
  SPEAKER_00: Some, OpenHands ADER, work outside the IDE via CLI.
• 10:35
  SPEAKER_00: Others, Cline, Continue, Gemini, integrate inside editors, and orchestration frameworks, Goose MCP-based, treat everything as a tool.
• 10:45
  SPEAKER_00: Enterprise Tailored Solutions.
• 10:47
  SPEAKER_00: Enterprise have begun embedding coding agents into their IT stacks, focusing on orchestration, governance, and scale.
• 10:54
  SPEAKER_00: UiPath for coding agents.
• 10:56
  SPEAKER_00: UiPath, a leader in robotic process automation, launched UiPath for Coding Agents in May 2026.
• 11:03
  SPEAKER_00: This platform treats AI coding agents as just another automation tool.
• 11:08
  SPEAKER_00: Companies can plug in any agent, Kogato Corps, OpenAIs, etc., into UiPath's visual workflows.
• 11:15
  SPEAKER_00: The idea is seamless end-to-end automation.
• 11:18
  SPEAKER_00: Build, test, deploy, with corporate controls around it.
• 11:22
  SPEAKER_00: UiPath touts orchestration at scale so that AI-generated code flows through the same audit permissions pipelines as human code.
• 11:30
  SPEAKER_00: Key features include role-based access, audit trails, credential vaults, and policy enforcement.
• 11:35
  SPEAKER_00: Essentially enforcing enterprise compliance on AI outputs.
• 11:39
  SPEAKER_00: In practice, large companies are using UiPath to wire agents into CICD pipelines and multi-system workflows, e.g., linking a JIRA issue to code changes without manual handoff.
• 11:51
  SPEAKER_00: JetBrain's AI Assistant.
• 11:53
  SPEAKER_00: JetBrains integrated agents into its IDE suite, IntelliJ, PyCharm, etc., via the AI Assistant plugin, released 2026.1.
• 12:02
  SPEAKER_00: Their docs describe coding agents as systems that autonomously plan and execute multi-step development tasks, editing files, running tests, invoking tools on your project.
• 12:13
  SPEAKER_00: JetBrains provides built-in agents, e.g.
• 12:15
  SPEAKER_00: Juni, Cloud Agent, Codex Agent, and a standard agent-client protocol, ACP, so enterprises can plug in their own models.
• 12:23
  SPEAKER_00: Users can tailor agents with project-specific instructions and skills, and every agent action requires explicit user approval or can be set to automatic based on mode.
• 12:33
  SPEAKER_00: This gives developers control over what AI changes make it into the code base.
• 12:38
  SPEAKER_00: JetBrains focuses on keeping agents inside familiar developer workflows, IDE windows, code reviews.
• 12:45
  SPEAKER_00: IBM WatsonX Code Assistant.
• 12:47
  SPEAKER_00: IBM markets WatsonX as an enterprise-ready coding assistant suite.
• 12:52
  SPEAKER_00: The GA announcement emphasizes enterprise Java modernization using AI-assisted analysis and refactoring.
• 13:00
  SPEAKER_00: IBM's offering plugs into IBM's hybrid cloud and DevOps tools.
• 13:05
  SPEAKER_00: It highlights security compliance, e.g.
• 13:08
  SPEAKER_00: RBAC audit logs, and is designed to handle large legacy code bases in regulated industries.
• 13:14
  SPEAKER_00: It also includes specialized modules, e.g., for mainframe code.
• 13:18
  SPEAKER_00: IBM's agent supports common enterprise languages, including Go, Java, Python, etc., and is sold as part of their Watson X AI platform, often behind corporate firewalls.
• 13:30
  SPEAKER_00: Other corporate solutions.
• 13:32
  SPEAKER_00: Many vendors now offer enterprise tiers or on-prem versions of AI coding tools.
• 13:37
  SPEAKER_00: GitHub Copilot for Enterprise lets companies deploy a private instance.
• 13:42
  SPEAKER_00: AWS Code Whisperers Professional Tier adds org-wide policy controls.
• 13:47
  SPEAKER_00: Atlassian built AI features into Jira and Bitbucket, e.g., enabling Copilot for pull requests.
• 13:54
  SPEAKER_00: Even security firms, SNCC checkmarks, are integrating LLMs to audit or generate code under policy constraints.
• 14:01
  SPEAKER_00: The unifying theme is governance, encryption of data, usage logging, and human in-the-loop checkpoints.
• 14:08
  SPEAKER_00: Taxonomy by capability.
• 14:10
  SPEAKER_00: Below we categorize agents on key dimensions.
• 14:13
  SPEAKER_00: Autonomy level, assisted assistance, low autonomy.
• 14:16
  SPEAKER_00: These are tools that suggest code but do not act on it without developer confirmation.
• 14:21
  SPEAKER_00: Typical examples GitHub Copilot, Basic Chat GPT code completion, IDE IntelliSense Plus, Tab 9, Codex via prompts.
• 14:30
  SPEAKER_00: They generate snippets or single functions, but developers must review and integrate each change manually.
• 14:36
  SPEAKER_00: Safety is high because the human gatekeeps all edits.
• 14:40
  SPEAKER_00: Interactive assistance, medium autonomy.
• 14:43
  SPEAKER_00: Agents that can carry multi-turn conversations or perform multi-step tasks with guidance.
• 14:48
  SPEAKER_00: For instance, a developer might chat with an agent to refactor code or write a module, and the agent executes code edits in response.
• 14:56
  SPEAKER_00: Examples include tools like ADER.
• 14:58
  SPEAKER_00: You request add error handling, it edits and commits, or chat GPT with code interpreter.
• 15:04
  SPEAKER_00: The user prompts for a task and gets executed answers.
• 15:08
  SPEAKER_00: These systems still loop with user feedback.
• 15:10
  SPEAKER_00: The human reviews tests or approves commits.
• 15:13
  SPEAKER_00: They often plan or outline steps, e.g.
• 15:16
  SPEAKER_00: JuniClaud agents and IDEs, but wait for user approval for final commits.
• 15:21
  SPEAKER_00: Autonomous agents, high autonomy.
• 15:23
  SPEAKER_00: At this level, the agent takes a high-level command and performs an entire workflow on its own.
• 15:29
  SPEAKER_00: It reads the code base, formulates a plan, edits files, runs tests, and even creates pull requests, all without step-by-step human props, though a developer may later review.
• 15:40
  SPEAKER_00: Anthropics Claude Code and Cursor in agent mode exemplify this.
• 15:44
  SPEAKER_00: You can say implement the user report feature, and the agent will iterate through writing code, running it, fixing errors, and committing the result.
• 15:53
  SPEAKER_00: They rely on built-in planning loops, e.g., Claude Code, can generate a plan outline before executing and will ask for confirmation on risky ops.
• 16:03
  SPEAKER_00: The UiPath orchestration layer even allows completely automated flows between agents.
• 16:09
  SPEAKER_00: These high autonomy agents require strong safety controls, approval slash recenters, but can dramatically boost productivity by handling the drudge work end-to-end.
• 16:20
  SPEAKER_00: Supported languages.
• 16:22
  SPEAKER_00: Modern agents typically cover all mainstream programming languages.
• 16:26
  SPEAKER_00: For example, web inscripting languages, Python, JavaScript, TypeScript, PHP, Ruby, Go, Rust, Kotlin, etc.
• 16:35
  SPEAKER_00: AWS Code Whisperer explicitly lists support for 13 plus languages, including Rust, Go, Kotlin, Scala, etc.
• 16:44
  SPEAKER_00: Ader touts 100 plus languages, naming Python, JavaScript, Rust, Ruby, Go, C C, PHP, HTML, CSS, and dozens more.
• 16:55
  SPEAKER_00: IBM's assistant likewise covers Go, Java, CC, JavaScript, Python, TypeScript, etc.
• 17:03
  SPEAKER_00: Enterprise slash legacy languages.
• 17:05
  SPEAKER_00: Java is universally supported.
• 17:07
  SPEAKER_00: Large commercial tools often also do Canned database languages, SQL, PL, SQL.
• 17:13
  SPEAKER_00: Mainframe languages, COBOL, are handled by specialized solutions.
• 17:17
  SPEAKER_00: IBM Suite has a C addition.
• 17:19
  SPEAKER_00: Infrastructure and Shell.
• 17:21
  SPEAKER_00: Many agents can generate shell scripts or SQL queries.
• 17:25
  SPEAKER_00: For instance, Cursor can accept a description of a system task and output a bash command.
• 17:30
  SPEAKER_00: The Gemini CLI has built-in access to run shell commands.
• 17:34
  SPEAKER_00: Code Whisperer even supports shell scripting.
• 17:37
  SPEAKER_00: In practice, virtually any language seen in public code can be handled by the LLM backends.
• 17:43
  SPEAKER_00: However, token limits and available training data means support quality may vary for very niche or proprietary languages.
• 17:50
  SPEAKER_00: Integration surfaces.
• 17:52
  SPEAKER_00: Coding agents hook into developers' workflows via multiple interfaces, IDEs and editors, the most common entry point.
• 18:00
  SPEAKER_00: VS Code and JetBrain's IDEs have plugins extensions for agents.
• 18:04
  SPEAKER_00: These appear as chat panes, sidebar tools, or code lens suggestions.
• 18:09
  SPEAKER_00: GitHub Copilot, Aider, Klein, Continue, Codex Agent, Juni, ClaudeAgent, etc.
• 18:14
  SPEAKER_00: all integrate here.
• 18:16
  SPEAKER_00: Within an IDE, you typically invoke an agent by commenting in code or using a command palette, and the agent can open edit files, run code, and show diffs inline.
• 18:26
  SPEAKER_00: Command line, CLI tools.
• 18:28
  SPEAKER_00: Developers also use terminal-based agents.
• 18:31
  SPEAKER_00: Examples, Codex CLI, OpenAI Tools, ADAR CLI, Goose's CLI, Gemini CLI.
• 18:38
  SPEAKER_00: These are dropped into a shell and given instructions, often via prompts or config files.
• 18:43
  SPEAKER_00: They operate on the local repository and can run commands or editors.
• 18:47
  SPEAKER_00: For instance, Codec CLI from OpenAI can be scripted to automate tasks, like in the Jira PR example.
• 18:54
  SPEAKER_00: CLI agents often allow scripting and integration into shell pipelines.
• 18:59
  SPEAKER_00: CICD pipelines.
• 19:00
  SPEAKER_00: Agents are increasingly called within build test pipelines.
• 19:04
  SPEAKER_00: For example, community-built GitHub actions, like AutoAgent, exist to run agents on pull requests.
• 19:12
  SPEAKER_00: But typical pattern, a GitHub action triggers on a PR, runs an agent, e.g.
• 19:18
  SPEAKER_00: cursor CLI or Codex CLI, to suggest improvements or run tests, and posts results back as comments.
• 19:26
  SPEAKER_00: This lets AI code analysis happen automatically on PR submit or notly builds, bridging agents into DevOps.
• 19:34
  SPEAKER_00: Some vendors may also offer Jenkins GitLab integration, often via webhooks or custom plugins.
• 19:41
  SPEAKER_00: Issue trackers and workflow tools.
• 19:43
  SPEAKER_00: Agents can integrate with task systems.
• 19:46
  SPEAKER_00: For instance, OpenAI's GitHub Cookbook shows automating Jira workflows.
• 19:51
  SPEAKER_00: Labeling a Jira ticket launches a GitHub action that runs an agent to create a PR and update both systems.
• 19:58
  SPEAKER_00: Similarly, tasks in Asana or Monday.com could trigger AI code tasks via webhooks.
• 20:04
  SPEAKER_00: This surface is still emerging, but shows how agents can connect tickets to commits.
• 20:10
  SPEAKER_00: Messaging and chat ops.
• 20:12
  SPEAKER_00: Although less common for coding specifically, some agents can be invoked via chat apps, Slack, Teams, Discord.
• 20:19
  SPEAKER_00: Tools like OpenClaw demonstrate agents listening on Slack or WhatsApp, and Google's Gemini CLI can be called from chat as well.
• 20:28
  SPEAKER_00: In a coding context, one might imagine Slack bots that run code agents upon request.
• 20:34
  SPEAKER_00: But currently, this is more experimental.
• 20:37
  SPEAKER_00: RPA orchestration.
• 20:38
  SPEAKER_00: Beyond dev tools, enterprise bots like UiPath workflows can orchestrate agents alongside other systems, databases, CRMs, etc.
• 20:48
  SPEAKER_00: UiPath's offering connects agents into an orchestrator which can invoke code agents, handle retries, and enforce policies across the enterprise fabric.
• 20:58
  SPEAKER_00: Safety and governance.
• 21:00
  SPEAKER_00: Because coding agents can modify production code, safety controls are critical.
• 21:05
  SPEAKER_00: Approaches include approval loops.
• 21:07
  SPEAKER_00: Agents often ask for confirmation before making significant changes.
• 21:11
  SPEAKER_00: For example, Anthropics Clawed Code plans its modifications ahead and requires approval for destructive actions.
• 21:18
  SPEAKER_00: JetBrain's assistant will propose changes and let the user review or roll back each diff.
• 21:24
  SPEAKER_00: This ensures a human is in the loop for risky edits.
• 21:27
  SPEAKER_00: Memory governance layers.
• 21:29
  SPEAKER_00: New research leverages memory to prevent repeated mistakes.
• 21:33
  SPEAKER_00: The Project MEM System 2026 is a prime example.
• 21:37
  SPEAKER_00: It records all dev events, issues opened, fixes attempted, decisions in an append only log and summarizes them as agent accessible memory.
• 21:46
  SPEAKER_00: Before the agent acts, Project MEM can warn if a similar fix failed before, effectively acting as a preaction gate or governance filter.
• 21:55
  SPEAKER_00: In other words, memory isn't just history and actively prevents repeated destruction.
• 22:00
  SPEAKER_00: Behavior.
• 22:01
  SPEAKER_00: Credential and environment sandboxing.
• 22:03
  SPEAKER_00: Enterprise solutions provide credential vaults and sandboxed runtimes.
• 22:07
  SPEAKER_00: For example, OpenClaw explicitly isolates each skill in a sandbox with limited file database access.
• 22:15
  SPEAKER_00: UiPath credentials management ensures agents can't access secret systems without permission.
• 22:22
  SPEAKER_00: Code interpreter style sandboxes, like OpenAIs, let the agent run code in an ephemeral environment containing any harmful effects.
• 22:32
  SPEAKER_00: RBAC and auditing.
• 22:34
  SPEAKER_00: Enterprises use traditional IT controls.
• 22:37
  SPEAKER_00: UiPath and IBM tools log every agent action and tie them to user identities.
• 22:43
  SPEAKER_00: And use role-based access, e.g., only senior devs may deploy AI changes.
• 22:49
  SPEAKER_00: Organizational policies can block certain actions outright, e.g., no internet access or no database rights.
• 22:58
  SPEAKER_00: Restricted model memory access.
• 23:00
  SPEAKER_00: Some platforms enforce instruction filters.
• 23:03
  SPEAKER_00: JetBrain's AI assistant stores project instructions that the agent must follow.
• 23:08
  SPEAKER_00: MCP frameworks limit tools via whitelists, e.g., an MCP Git server only exposes safe commands.
• 23:16
  SPEAKER_00: Language model providers may also offer filters on code, scanning for insecure patterns.
• 23:22
  SPEAKER_00: In summary, every agentic system combines technical guardrails, sandboxes, whitelists, with review processes, human approval, audits.
• 23:32
  SPEAKER_00: This layered safety is critical whenever AI has right privileges on live code.
• 23:37
  SPEAKER_00: Deployment models, SaaS versus self-hosted.
• 23:41
  SPEAKER_00: Coding agents come in two broad deployment flavors, SaaSlash Cloud.
• 23:45
  SPEAKER_00: Many commercial agents are offered as cloud services.
• 23:48
  SPEAKER_00: For example, Copilot, GitHub, and Code Whisperer AWS run on the provider's servers and you access them via an API or extension.
• 23:57
  SPEAKER_00: Google's hosted Gemini models are similarly cloud-based.
• 24:01
  SPEAKER_00: SaaS versions require internet access and typically involve sending code snippets to the vendor.
• 24:07
  SPEAKER_00: The benefits are ease of use and always updated models.
• 24:11
  SPEAKER_00: For enterprise SaaS offerings, vendors often isolate customer data and offer private instances.
• 24:17
  SPEAKER_00: Example, AWS Code Whisperer GA is delivered as a cloud service, free and pro tiers.
• 24:24
  SPEAKER_00: Customers simply enable the service in their IDEs, AWS console, and the heavy lifting happens in AWS.
• 24:31
  SPEAKER_00: The trade-off is trusting the vendor with code snippets.
• 24:34
  SPEAKER_00: Self-hosted on-prem.
• 24:36
  SPEAKER_00: To keep code private or comply with regulations, many frameworks allow on-premise deployment.
• 24:42
  SPEAKER_00: Open source projects typically run on your own hardware.
• 24:46
  SPEAKER_00: OpenClaw is expressly fully self-hosted.
• 24:49
  SPEAKER_00: Nothing ever leaves your servers.
• 24:51
  SPEAKER_00: Open hands and Boose can run on a local machine or corporate cloud.
• 24:55
  SPEAKER_00: You control the LLM instances.
• 24:57
  SPEAKER_00: Gemini CLI can run with a local LLM as backend or be containerized.
• 25:03
  SPEAKER_00: Some systems, like Project MEM, are local first.
• 25:06
  SPEAKER_00: Example, Open Hands can integrate with local LLMs via Olama or VLLM, running entirely on your GPU.
• 25:13
  SPEAKER_00: Similarly, Goose's desktop slash CLI runs natively and connects to local or private models.
• 25:20
  SPEAKER_00: Enterprises often install local inference servers, Anthropics CloudSonnet on-prem or Azure AI Studio private models.
• 25:28
  SPEAKER_00: So agents operate behind the firewall.
• 25:31
  SPEAKER_00: Hybrid models.
• 25:33
  SPEAKER_00: A common pattern is a hybrid cloud plus local setup.
• 25:36
  SPEAKER_00: For example, open hands or goose might use a local GPU for common operations, but fall back to a larger cloud model for tough tasks.
• 25:45
  SPEAKER_00: Clonts on it via API with local fallback.
• 25:48
  SPEAKER_00: Or tools like Gemini CLI are open source but rely on Google's Cloud LLM, which may be considered SaaS.
• 25:56
  SPEAKER_00: In practice, the choice depends on priorities.
• 25:59
  SPEAKER_00: Startups and individual developers often use SaaS for convenience.
• 26:03
  SPEAKER_00: Larger teams with sensitive code often opt for self-hosted models, many open source agents, or controlled cloud offerings.
• 26:12
  SPEAKER_00: The good news is both are available.
• 26:14
  SPEAKER_00: Dozens of frameworks explicitly support hybrid operation, any LLM, any MCP tool to fit either model.
• 26:22
  SPEAKER_00: Research lineages.
• 26:23
  SPEAKER_00: Several research threads converge in today's agents.
• 26:26
  SPEAKER_00: Key lineages include Transformer and LLM Progress.
• 26:30
  SPEAKER_00: The entire field rests on Transformer Architectures, Vaswani et al.
• 26:35
  SPEAKER_00: 2017, and large-scale language modeling.
• 26:38
  SPEAKER_00: In 2019 to 2020, GPT-2.3 OpenAI showed that massive unsupervised training made models very fluent.
• 26:46
  SPEAKER_00: GPT-3 popularized in-context learning, meaning a model could be prompted with examples, instructions instead of fine-tuning.
• 26:54
  SPEAKER_00: This turns prompting into programming leverage.
• 26:57
  SPEAKER_00: In 2021, OpenAI's codex, GPT-3 fine-tuned on code, achieved breakthrough performance on code benchmarks, human-eval, and directly powered GitHub Copilot.
• 27:09
  SPEAKER_00: Chain of thought and planning.
• 27:11
  SPEAKER_00: Early LLMs just output text.
• 27:14
  SPEAKER_00: Work in 2022, React, Yao et OW, made reasoning and acting an explicit loop.
• 27:20
  SPEAKER_00: React taught models to interleave chain of thought with tool calls, effectively letting the LLM reason step by step about code tasks.
• 27:28
  SPEAKER_00: Related work like MetaS Toolformer, 2023, trained models to decide when to call an API during generation.
• 27:36
  SPEAKER_00: These ideas directly feed into coding agents' designs, where the AI writes some code, tests it via an interpreter, sees errors, and refines its answer.
• 27:45
  SPEAKER_00: A simple feedback loop.
• 27:47
  SPEAKER_00: Terminal native agents like Claude Code exemplify this.
• 27:50
  SPEAKER_00: They internally generate a plan of attack, execute it, observe test results, and replan if needed.
• 27:57
  SPEAKER_00: Agent frameworks and looping.
• 27:59
  SPEAKER_00: In 2023, popular demos like AutoGPT showed how to layer a managing LLM over subtasks.
• 28:06
  SPEAKER_00: AutoGPT spawned subagents to reach high-level goals by creating tasks, executing them, and iterating on results, though often unstable.
• 28:16
  SPEAKER_00: Around 2024, the community pivoted from splashy demos to systematic agent frameworks.
• 28:22
  SPEAKER_00: These frameworks provide reusable shells for agents, hooked-in memory, standardized tool interfaces, permission models, etc.
• 28:29
  SPEAKER_00: By 2025, terminal native agents, CLI-based repo assistants became a product category.
• 28:38
  SPEAKER_00: For example, Claude Code and Cursor popularized the pattern, repo aware context, structured tools, plus user approvals.
• 28:46
  SPEAKER_00: Many open source frameworks coalesced on similar designs.
• 28:50
  SPEAKER_00: Context windows for code, integrated Git tools, explicit user confirmation.
• 28:56
  SPEAKER_00: Memory augmentation.
• 28:58
  SPEAKER_00: A critical research lineage is memory.
• 29:00
  SPEAKER_00: Standard LLMs are stateless beyond their input context, which is limited.
• 29:05
  SPEAKER_00: Recent work recognizes that coding agents need long-term memory.
• 29:09
  SPEAKER_00: A March 2026 survey by Do et al.
• 29:13
  SPEAKER_00: formalizes agent memory as a write-manage read loop and reviews approaches, in-context summarization, retrieval buffers, learned memory policies, etc.
• 29:22
  SPEAKER_00: They note coding agents often suffer from limited context, 5,000 to 20,000 tokens per session lost with each run and need persistent logs.
• 29:32
  SPEAKER_00: Project MEM, June 2026, is a concrete example.
• 29:36
  SPEAKER_00: It records every developer event, bugs, fixes, decisions, to avoid repeating past errors.
• 29:42
  SPEAKER_00: In effect, memory becomes governance, an agent won't commit a fix already tried.
• 29:47
  SPEAKER_00: This line differs from vanilla LLM research, which mostly focuses on single-session tasks by integrating multi-session, stakeful behavior.
• 29:56
  SPEAKER_00: In summary, modern coding agents bring together scalable LLMs, GPT-3, 4, Claude, Gemini, Llama derivatives, with agentic reasoning patterns, chain of thought, React, planning loops, and tool interfaces, sandboxes, git shells.
• 30:11
  SPEAKER_00: Differences between systems often boil down to degree of autonomy, memory usage, and tool integration, but all share the plan act observe cycle.
• 30:20
  SPEAKER_00: Timeline of key developments.
• 30:22
  SPEAKER_00: 2017.
• 30:23
  SPEAKER_00: The Transformer architecture is introduced, enabling context-aware modeling of code.
• 30:28
  SPEAKER_00: 2019 to 2020, GPT 2GPT3 demonstrate emergent in-context learning.
• 30:34
  SPEAKER_00: Models can follow prompts to write coherent text code without fine-tuning.
• 30:38
  SPEAKER_00: 2021, OpenAI's Codex model is released.
• 30:42
  SPEAKER_00: Trained on publicly available code, Codex achieves state-of-the-art on code benchmarks and powers GitHub Copilot.
• 30:49
  SPEAKER_00: AI code suggestions, autocomplete, become mainstream, the co-pilot era.
• 30:54
  SPEAKER_00: June 2022, Amazon launches Code Whisperer, GA in April 2023, a GitHub-like AI coding companion integrated in AWS Tools.
• 31:05
  SPEAKER_00: November 2022, ChatGPT, GPT 3.5 Turbo is released by OpenAI, quickly gaining popularity as a multi-turn code assistant, though not a full agent.
• 31:15
  SPEAKER_00: October 2022, the React paper appears, establishing the Think Then Act paradigm for LLMs.
• 31:22
  SPEAKER_00: 2023, Early.
• 31:24
  SPEAKER_00: Meta releases ToolFormer May, and OpenAI releases Code Interpreter, later branded ADA, November, demonstrating AI self-verifying code in a sandbox.
• 31:34
  SPEAKER_00: 2023, AutoGPT demos popularize recursive multi-agent loops.
• 31:39
  SPEAKER_00: Open source frameworks spring up, e.g.
• 31:42
  SPEAKER_00: OpenAI's Codex CLI, Google's Gemini CLI, Community Projects.
• 31:49
  SPEAKER_00: June 2025.
• 31:50
  SPEAKER_00: Startup AnySphere Cursor raises$900 million, valuing the company at$9.9B dollars.
• 31:57
  SPEAKER_00: Competitive landscape.
• 31:59
  SPEAKER_00: OpenAI acquires Windsurf,$3B, and GitHub Copilot hits minus 500 million ARR.
• 32:06
  SPEAKER_00: Feb 2025, Anthropic launches Claude Code, a first of its kind terminal native coding agent.
• 32:13
  SPEAKER_00: It can read-write local files, run tests, and spawn subagents for tasks.
• 32:19
  SPEAKER_00: Within months it accrues a dedicated user base and$1 billion ARR revenue.
• 32:25
  SPEAKER_00: May 2026, UiPath unveils UiPath for coding agents, tying agents into enterprise CICD and governance.
• 32:33
  SPEAKER_00: JetBrain ships its 2026.1 release with built-in coding agents, Juni ClaudAgent.
• 32:40
  SPEAKER_00: June 2026, open source memory systems for agents debut, e.g.
• 32:45
  SPEAKER_00: Project MEM.
• 32:46
  SPEAKER_00: The industry consensus is that the cutting edge is a full stack agent in the terminal IDE with strong governance, as reflected in many products.
• 32:54
  SPEAKER_00: Conclusion, getting started.
• 32:56
  SPEAKER_00: The autonomous coding agent ecosystem is vast and rapidly evolving.
• 33:00
  SPEAKER_00: But the good news is AI has unlocked coding for everyone.
• 33:04
  SPEAKER_00: As a newcomer, you don't have to build a system from scratch.
• 33:08
  SPEAKER_00: First, try an AI coding assistant in your everyday tools.
• 33:12
  SPEAKER_00: For example, install GitHub Copilot or AWS Code Whisperer in Visual Studio Code.
• 33:18
  SPEAKER_00: Both have free tiers or trials.
• 33:20
  SPEAKER_00: Open a simple project and ask the AI to write or refactor a small function.
• 33:25
  SPEAKER_00: This will show you how an agent can autocomplete code and suggest commits.
• 33:29
  SPEAKER_00: Alternatively, use ChatGPT's code interpreter, if available to you, on a sample Python script to see how it runs code and refines answers.
• 33:38
  SPEAKER_00: Once comfortable, experiment with an open agent.
• 33:41
  SPEAKER_00: For instance, install the OpenHand CLI or ADER and given a task, e.g., add unit tests for this function.
• 33:49
  SPEAKER_00: Observe how it edits files and commits changes.
• 33:52
  SPEAKER_00: You can also try the Gemini CLI open source to interact with Google's models locally.
• 33:57
  SPEAKER_00: For managing projects, look at JetBrain's AI Assistant, JuniClaude, or VS Code's continue extension.
• 34:04
  SPEAKER_00: Many integrate seamlessly with Git and issue trackers.
• 34:08
  SPEAKER_00: The next step in your product creation journey is to integrate an agent into a real workflow.
• 34:13
  SPEAKER_00: For example, add a GitHub action that runs a CLI agent on every pull request, as in OpenAI's Jira to PR example.
• 34:21
  SPEAKER_00: Or try building a small agent skill using the OpenHands SDK, following its docs to automate a repetitive task in your code base.
• 34:29
  SPEAKER_00: There are tutorials on OpenHands site and many community examples on GitHub.
• 34:34
  SPEAKER_00: Throughout, remember, always keep safety in mind.
• 34:37
  SPEAKER_00: Review the agent's changes, set up test suites, and use sandbox features.
• 34:42
  SPEAKER_00: Many frameworks let you start in a read-only mode until you're confident.
• 34:46
  SPEAKER_00: In sum, start small, learn by doing, and progressively trust these tools with more of your workflow.
• 34:53
  SPEAKER_00: Autonomy in coding is here to stay.
• 34:56
  SPEAKER_00: By June 2026, we have a rich ecosystem spanning hobbyist scripts to enterprise platforms.
• 35:04
  SPEAKER_00: Whether you're an individual developer or running a large team, there's an agentic solution for you.
• 35:10
  SPEAKER_00: The key is to jump in, experiment with the tools listed here, and iterate.
• 35:15
  SPEAKER_00: In doing so, you'll join the wave of teams and companies building tomorrow's software faster, with AI as a true development partner.
• 35:24
  SPEAKER_00: All links to sources are available in the text version of this article.
• 35:28
  SPEAKER_00: You can find the full article at easycoding.tools.blog.
• 35:32
  SPEAKER_00: Thanks for listening.
• 35:33
  SPEAKER_00: For more practical AI coding guides, tool comparisons, and resources for builders, visit easycoding.tools.
• 35:41
  SPEAKER_00: And if it's easier to remember, just go to aibuilds.it.
• 35:45
  SPEAKER_00: It redirects to easycoding.tools.