AGNTCon + MCPCon Japan 2026

From a green software perspective, waste in agentic AI comes not only from model choice, but also from workflow design. Agent workflows combine planning, retrieval, retries, memory, tools, and model calls. Poor controls can lead to large models for simple tasks, long histories, repeated retrieval, or needless tool calls, increasing compute, cost, and latency.

This talk presents a design-review approach for reducing unnecessary computation in agent workflows. As a case study, it uses Lean Agentic AI (https://github.com/navveenb/lean-agentic-ai) as an open-source workflow example. For each workflow step, it asks: Is an LLM needed? Is the model appropriate? Is context bounded? Could code, rules, or a smaller model replace a large-model call?

The goal is not precise carbon accounting. Instead, it identifies avoidable inference, oversized context, and needless tool calls before estimating CO2 emissions.

Takeaways:
* See how agent workflow design affects compute, cost, and latency.
* Understand how reducing unnecessary computation supports green software goals.
* Ask simple review questions to reduce unnecessary LLM calls, retrieval, memory, and tool use.

A production issue spans multiple cloud environments. Everything looks fine in isolation, but the system behaves unexpectedly end-to-end. Reconstructing what is actually deployed requires stitching together cloud consoles, infrastructure definitions, and internal tooling.

AI agents could help with this kind of problem, but they need better context. Infrastructure is a key part of that context gap. Cloud resources, environments, configurations, and policies are essential for reasoning and decision-making, yet this information is fragmented across infrastructure-as-code, cloud providers, and internal systems.

This talk explores why a developer platform was built: to unify infrastructure management, standardize how teams provision and manage cloud resources, and provide a consistent abstraction across providers, accounts, and environments. The platform then evolves into a unified source of infrastructure context, aggregating metadata into a coherent infrastructure blueprint. By exposing this through an MCP server, it allows AI agents to understand the full infrastructure landscape, improving reasoning, troubleshooting, and the quality of assistance in engineering workflows.

Most agent memory is a chat log with extra steps. Dump turns into a vector store, retrieve the top-k by cosine similarity, and hope the right context shows up. It usually doesn't, and the agent pays for it three turns later.

agentmemory MCP Server began as a fix for that. It combines BM25, dense vector search, and a knowledge graph, fuses them with reciprocal rank fusion, and ages stored memories on an Ebbinghaus forgetting curve so old context decays instead of drowning new signal. On LongMemEval-S it reaches 95.2% recall
at 5. The repo trended on GitHub, ranked on Product Hunt, got picked up by AlphaSignal, and was recognized by the Agentic AI Foundation, none of it paid for.

This talk covers how it was built and where the easy version breaks. Single-method retrieval looks fine in a demo and falls apart on long histories. I'll show why each method earns its place, how the pieces compose with one engine an agent can query over MCP, and which design decisions held up once real workloads hit them.

You'll leave with a memory model that beats top-k vector search and a clear picture of how to expose it to agents through MCP.

AI coding agents are useful in isolated demos; the hard problem is making them controlled enough to ship production code. At Delphi, we built an agentic software factory that turns product specs and engineering tickets into scoped pull requests, then routes those PRs through reviewer agents, CI, browser verification, and merge gates.

This session breaks down the operating system around the agents: how we package repo context, encode architectural rules, isolate attempts in worktrees, make agents cite source-of-truth patterns, prevent drift from legacy code, and decide what should stay human-controlled. I will also cover failure modes we hit in production: stale context, over-broad diffs, flaky tests, review spam, false confidence, and agents copying the wrong pattern.

Attendees will leave with a practical blueprint for moving from “agent writes code” to a controlled delivery pipeline for agent-generated software

Technical debt lives in code. Cognitive debt lives in your head. Intent debt, Addy Osmani's term for the goals, constraints, and rationale behind a decision that never got written down, lives nowhere. It's the one debt agents can't pay down: an agent drafting a spec fills the gap with a confident guess, and the guess is usually wrong.

This talk covers building context graphs that capture the why: connecting decisions to the document threads and ticket discussions where humans actually made them, then exposing that structure to agents alongside code and data. I'll draw on an open-source toolkit that bootstraps context graphs from existing work artifacts (workspace threads, ticket histories) and the modeling questions that turned out hard: what separates a decision from a discussion, and when capture should run as a background process versus an explicit act.

Vendors now race to pitch "context layers for agents." I'll argue the differentiator isn't collection but connection: rationale linked to the entities, people, and prior choices it affects: queryable, not just retrievable.

You'll leave with patterns for making the why available to every agent that touches your work.