What even is an AI Agent?! (The Standup)

AI agents for software development are essentially an LLM wired to programming tools and kept running through iterative “loops” until the task is complete—but the hard part isn’t the core loop. The hard part is making the experience reliable, safe, and usable inside real developer workflows, especially when the agent needs access to a local codebase and the developer’s existing setup.

In a discussion focused on Open Code, the team frames an agent as “LLM + tools + loops + a system prompt” that guides the model to repeatedly call tools like editing files, reading project context, and running commands. The loop behavior largely comes from the model itself: when the model can’t proceed without tool results, it stops and requests specific tool calls, then continues after receiving outputs. That design means developers don’t have to handcraft the interruption logic for every step; the model’s stop reasons and tool-call protocol drive the iteration.

Open Code’s differentiation is less about squeezing extra capability from models and more about packaging an agent that fits how programmers already work—particularly in the terminal. The product aims to run the agent on the user’s machine with access to local files, rather than forcing developers to recreate their environment in the cloud. That local-first approach also enables a planned mobile client: the laptop can keep running while the developer steps away, with notifications and the ability to continue the conversation later. The team emphasizes that this matters because most dev environments are local, and remote agents require duplicating configuration that many teams don’t maintain consistently.

A concrete example shows how Open Code reduces hallucinations and improves correctness: edits trigger diagnostics from the Language Server Protocol (LSP). When the agent applies a patch to a file, the system returns LSP errors (for example, TypeScript diagnostics). The agent then uses those diagnostics as feedback to fix issues immediately, correcting mistaken assumptions about missing functions or incorrect types. Open Code runs LSP servers in parallel rather than trying to hijack already-running ones, and it ships out-of-the-box support so users don’t need perfect custom configuration.

The team also tackles why “agentic coding” is still messy in practice. Models differ in how eagerly they call tools, and tool-calling behavior is shaped by training and system prompts; some models require more explicit tool instructions to use the right functions. Because the system prompt and tool schemas can change outcomes in non-obvious ways, the team says it’s building consistent, real-world benchmarks for agent behavior—using a shared codebase and qualitative evaluation—since traditional model benchmarks don’t correlate well with real developer tasks.

Finally, the discussion highlights operational edge cases that don’t show up in weekend demos: handling cancellations mid-tool-call, managing context-window limits, and dealing with the non-determinism of LLM behavior. Open Code addresses long sessions by summarizing history when context pressure rises, while also warning that summaries are lossy. The overall message: building an agent isn’t just about getting the loop working—it’s about engineering the surrounding system so it stays safe, correct, and productive in the messy reality of software development.