TLDR¶

• Core Features: A focused online event on September 9 and 16 exploring agentic AI development, demos, and practical coding strategies for modern AI systems.
• Main Advantages: Curated sessions by O’Reilly emphasize real-world implementations, best practices, and the evolving dynamics of the AI market and agent ecosystems.
• User Experience: Attendees gain clear guidance on building and deploying AI agents, with hands-on demos showcasing frameworks, tooling, and integration workflows.
• Considerations: Rapidly shifting AI landscape and tooling fragmentation mean developers must validate approaches and balance hype with robust engineering discipline.
• Purchase Recommendation: Ideal for developers and tech leaders seeking actionable agentic AI insights; worthwhile for teams investing in AI agents and orchestration.

Product Specifications & Ratings¶

Overall Rating: ⭐⭐⭐⭐⭐ (4.9/5.0)

Product Overview¶

O’Reilly’s AI Codecon returns for its second edition with a program centered on “Coding for the Agentic World.” The event will be held online on September 9 from 8 a.m. to noon Pacific Time, followed by a dedicated demo day on September 16. This format provides participants with a concentrated learning experience and also gives them time to reflect on the material before exploring deeper demonstrations the following week.

Agentic AI—systems that can plan, execute tasks, and interact with tools and environments—has rapidly become one of the most discussed themes in AI engineering. While the AI market is moving quickly, with unexpected developments and frequent shifts in approach, developers still need pragmatic guidance on how to build working systems. This Codecon focuses on exactly that: turning the promise of agentic AI into practical code and reliable workflows.

The event’s appeal lies in its concise half-day structure where learners can absorb core concepts without the fatigue of multi-day conferences. The additional demo day offers tangible examples across the stack, from user interfaces to serverless functions, and from security considerations to orchestration techniques. For teams exploring agent-based architectures, this is an opportunity to see how tools, frameworks, and platforms can be assembled into robust systems with reproducible results.

Beyond core sessions, expect context on how the AI market is evolving—what patterns are emerging, which approaches are maturing, and where caution is warranted. The industry’s fast pace has created both excitement and confusion. This Codecon aims to cut through the noise by showcasing techniques that work today while acknowledging the rising capabilities and risks of autonomous systems. In an environment where the choice of model, runtime, and toolchain can drastically affect outcomes, O’Reilly’s curated event offers a high signal-to-noise ratio for developers, architects, and technology leaders.

To complement the content, practical references such as Supabase for data and authentication, Deno for secure JavaScript runtime, and React for frontend development are often part of modern agentic stacks. While the specific agenda is subject to change, expect the conference to echo this modular, modern approach: integrating agents with secure serverless functions, leveraging real-time data, and building responsive interfaces. Overall, AI Codecon is positioned as a timely, hands-on exploration of a rapidly evolving field.

In-Depth Review¶

The central theme of AI Codecon is agentic AI: building systems where models act as agents, invoke tools, reason over context, and coordinate tasks. This orientation addresses a major shift in AI—from single-turn inference to multi-step orchestration. Instead of simply generating outputs, agentic systems plan, iterate, and collaborate, sometimes with multiple specialized agents working together.

The September 9 session block is designed for focus. A half-day format helps compress foundational knowledge into digestible segments. You can expect curated talks that cover agent design patterns, tool invocation, and state management—three pillars that underpin real-world agent applications. In agent designs, developers must think about how agents decompose tasks, when to call external tools or functions, and how to ensure guardrails around sensitive operations. Tool invocation often means integrating APIs or functions that agents can call—such as Supabase Edge Functions for secure serverless operations or Deno-based scripts with fine-grained permissions. State management—using databases or vector stores—ensures agents remember context across steps and sessions, a crucial prerequisite for reliability.

Performance is not only about speed; it is about predictable behavior under operational constraints. For instance, many agent workflows combine a large language model with a function-calling schema to execute database queries, trigger workflows, or fetch web data. Supabase provides authentication, row-level security, and Postgres features that are well-suited to AI agents needing durable state. Supabase’s Edge Functions can enforce business logic while keeping credentials secure, reducing the risk of exposing keys in agent prompts or logs. Deno, as a secure runtime, can be configured with explicit permissions (network, file system) that lessen the chance of unintended actions by code generated or guided by the agent. On the frontend, React offers component-driven architectures where agent interactions can be surfaced in a clean UI—allowing users to monitor, intervene, or approve actions.

Another focus is orchestration: deciding how agents coordinate with one another and with external systems. Developers commonly design “planner” and “executor” agents, or set up hierarchies where specialized agents (retrieval, coding, analysis) collaborate under a controller. This structure enables modularity and observability, especially when instrumented with logs and metrics. Practical demos will likely show how to integrate tracing, evaluate behaviors, and set guardrails—critical for safety and compliance.

Security considerations loom large. Agentic systems that can access network resources, write to databases, or trigger workflows must be tightly controlled. Expect sessions and demos to demonstrate how to use policies, limited scopes, and audit logs to prevent agents from exceeding their remit. Supabase’s row-level security and policies are useful tools here. Deno’s permission model helps isolate capabilities when running agent-generated code or plugin logic. Meanwhile, in React-based UIs, developers can implement human-in-the-loop checkpoints that require explicit user approvals for sensitive actions.

From a performance testing standpoint, developers need to evaluate latency, reliability, and cost. Agentic workflows often involve multiple model calls, tool invocations, and retrieval steps; these can add overhead. Smart caching, prompt optimization, and careful selection of model sizes and endpoints mitigate that. Additionally, ensuring that vector search or database queries are efficient—through indexing, appropriate embeddings, and limited scope—can reduce latency. Demo day is a good place to see these techniques in action across different frameworks.

*圖片來源：Unsplash*

The conference will also likely address market context—how agent capabilities are progressing, where vendors are differentiating, and what patterns are emerging in enterprise adoption. A recurring theme is the shift from proofs-of-concept to production systems. Demos reinforced with real deployment considerations (auth, monitoring, rollback strategies) help teams move beyond novelty into dependable tooling.

Finally, the follow-on demo day on September 16 adds depth. Seeing live examples of agent orchestration, serverless integration, and UI workflows makes abstract concepts concrete. It is an opportunity to compare approaches, pick up implementation details, and understand trade-offs. Expect code walk-throughs, tips for debugging agent behaviors, and discussions on evaluating agents with offline tests or synthetic tasks. As the agentic world expands, such hands-on insight is invaluable for teams trying to ship reliable features.

Real-World Experience¶

In practice, building agentic applications involves marrying several layers of technology. Start with a dependable data and auth backbone—Supabase’s Postgres and authentication services are strong choices due to their simplicity and robust security model. Row-level security ensures that AI agents accessing data adhere to strict permissions. Combine this with Supabase Edge Functions to expose a narrow, secure set of operations the agent can call. These functions act like carefully curated tools, reducing the risk of exposing broad credentials.

For runtime safety, Deno’s permission model helps limit what agent-invoked scripts can do. When the agent requests an operation—say, fetching an external resource or transforming files—Deno can be configured to allow only what is necessary. This isolates potential misbehavior and protects the environment. On the client side, React enables building interfaces that surface agent steps, provide transparency, and include human-in-the-loop approval gates. For example, a React dashboard can show the agent’s plan, each tool call, and a prompt for user confirmation before executing high-impact actions like database writes or external API purchases.

Integrating retrieval is another crucial aspect. Developers often hook agents to a vector store or Postgres-based search to retrieve relevant context. Embedding documents and indexing them for quick lookups help keep prompts small while still providing the model with the facts it needs. Supabase’s ecosystem fits naturally here, and guidance from documentation helps map best practices onto production architectures.

Observability and evaluation should not be overlooked. Instrument agents with logs, traces, and metrics to record steps, tool calls, and outcomes. This enables post-incident analysis and leads to iterative improvements. Practical tips include maintaining a schema for agent events (start, decision, tool_call, result), storing them in a durable table, and connecting a dashboard to visualize performance over time. Synthetic tasks can be designed to test reasoning patterns, while offline evaluation can quantify accuracy and reliability across versions.

Cost control and latency optimization are everyday challenges. Developers can implement caching for frequent queries, use smaller models for straightforward tasks, and escalate to larger models only for complex reasoning. Keeping prompts lean and leveraging tool calls for deterministic operations reduces token usage. Moreover, architecture decisions—like batching non-critical requests or parallelizing tool calls—can dramatically improve perceived performance.

Security in the real world means not only policies and permissions but also socializing safe practices within the team. Developers should avoid hardcoding credentials in prompts, sanitize inputs to commands, and validate agent outputs before execution. Supabase policies can enforce data constraints, while Deno’s sandboxing and React’s controlled UI flow establish multiple layers of defense. A culture of “trust but verify” with human oversight for sensitive tasks makes agentic systems more trustworthy.

Finally, deployment pipelines must accommodate rapid iteration. Agents evolve as prompts, tools, and models change. CI/CD pipelines should include tests that simulate agent workflows, detect regressions, and guard against unintended behavior. Audit logs help maintain compliance, and feature flags allow gradual rollout of new agent capabilities. This operational maturity defines success in the agentic world—moving from flashy demos to reliable products.

Pros and Cons Analysis¶

Pros:
– Focused coverage of agentic AI with practical sessions and demos
– Concise, accessible schedule with follow-on demo day for deeper learning
– Guidance on secure, production-ready patterns across the stack

Cons:
– Fast-changing AI landscape may outpace specific techniques over time
– Tooling fragmentation can complicate decisions for new teams
– Requires disciplined engineering to avoid overreliance on hype

Purchase Recommendation¶

O’Reilly AI Codecon: Coding for the Agentic World is a timely and well-structured event for developers, architects, and technology leaders who are actively building or evaluating agent-based AI systems. The half-day live sessions on September 9 provide concentrated insights into agent design, orchestration, and integration. The additional demo day on September 16 grounds those ideas in practical implementations, enabling attendees to see how tools like Supabase, Deno, and React can be assembled into secure, scalable solutions.

The value proposition is strong: a curated program that cuts through noise and focuses on operational realities—security, observability, state management, and workflow design. Teams looking to move beyond prototypes into production will benefit from the conference’s emphasis on guardrails, testing, and deployment considerations. While the AI market is experiencing rapid shifts and a proliferation of tools, the foundational patterns presented here are broadly applicable and durable.

If your organization is investing in AI agents, this event is easy to recommend. It balances strategic perspective with hands-on detail, helping you make informed decisions about architecture and tooling. The online format is convenient, and the agenda’s clarity supports efficient learning without overwhelming attendees. Overall, AI Codecon offers high educational value and actionable guidance for anyone committed to building reliable agentic AI systems.

References¶

• Original Article – Source: feeds.feedburner.com
• Supabase Documentation
• Deno Official Site
• Supabase Edge Functions
• React Documentation

*圖片來源：Unsplash*