BEGIN:VCALENDAR
VERSION:2.0
X-WR-CALNAME:agntconmcpconjapan26
X-WR-CALDESC:Event Calendar
METHOD:PUBLISH
CALSCALE:GREGORIAN
PRODID:-//Sched.com AGNTCon + MCPCon Japan 2026//EN
X-WR-TIMEZONE:UTC
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260909T230000Z
DTEND:20260910T093000Z
SUMMARY:Registration & Badge Pick-Up
DESCRIPTION:\n
CATEGORIES:SPECIAL EVENTS / EXHIBITS / BREAKS
LOCATION:B1F Foyer (Outside Hall C)\, Tokyo\, Japan
SEQUENCE:0
UID:0c9df685d21bb052232b2d5432aa93f0
URL:http://agntconmcpconjapan26.sched.com/event/0c9df685d21bb052232b2d5432aa93f0
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T000000Z
DTEND:20260910T001000Z
SUMMARY:Keynote: Welcome - Angie Jones\, Vice President of Developer Experience\, The Agentic AI Foundation
DESCRIPTION:\n
CATEGORIES:KEYNOTE SESSIONS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:4b6785db08c328d98f26cadac86b9fc2
URL:http://agntconmcpconjapan26.sched.com/event/4b6785db08c328d98f26cadac86b9fc2
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T001000Z
DTEND:20260910T002000Z
SUMMARY:Keynote: David Soria Parra\, Member of Technical Staff\, Anthropic
DESCRIPTION:\n
CATEGORIES:KEYNOTE SESSIONS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:42d3f2db575bdda82db12104f870e1e4
URL:http://agntconmcpconjapan26.sched.com/event/42d3f2db575bdda82db12104f870e1e4
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T002000Z
DTEND:20260910T003000Z
SUMMARY:Keynote: Lin Sun\, Head of Open Source\, Solo.io
DESCRIPTION:\n
CATEGORIES:KEYNOTE SESSIONS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:93327a8c4235b4b8c2556d42b9010dc8
URL:http://agntconmcpconjapan26.sched.com/event/93327a8c4235b4b8c2556d42b9010dc8
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T003500Z
DTEND:20260910T004500Z
SUMMARY:Keynote: Kaz Sato\, Staff Developer Advocate\, Cloud AI\, Google
DESCRIPTION:\n
CATEGORIES:KEYNOTE SESSIONS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:ea8c0dac8c0845ad9053c10ffe284c66
URL:http://agntconmcpconjapan26.sched.com/event/ea8c0dac8c0845ad9053c10ffe284c66
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T004500Z
DTEND:20260910T010500Z
SUMMARY:Coffee Break
DESCRIPTION:\n
CATEGORIES:SPECIAL EVENTS / EXHIBITS / BREAKS
LOCATION:Hall A\, Tokyo\, Japan
SEQUENCE:0
UID:78bd74d32e55f46e9ef577e5380b1bbd
URL:http://agntconmcpconjapan26.sched.com/event/78bd74d32e55f46e9ef577e5380b1bbd
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T010500Z
DTEND:20260910T013000Z
SUMMARY:Stateless MCP: Inside the 2026 Transport Spec - Himanshu Sangshetti\, Mem0
DESCRIPTION:Most MCP servers in production today are stateful- each client session is pinned to one server instance. \n \n That works on a single node. Add a load balancer and scale horizontally\, and sessions start breaking: Kubernetes routes a request to the wrong pod\, a Fargate deployment rolls and drops active connections\, and NGINX or AWS ALB need special configuration just to keep the server reachable. \n \n The 2026 spec release candidate\, locked May 21\, fixes this at the transport layer through three SEPs. \n - SEP-1442 removes the mandatory init handshake so negotiation folds into the first request. \n - SEP-2322 makes elicitation stateless. \n - SEP-2243 mirrors routing data into HTTP headers so load balancers can route without parsing the payload. \n \n This session covers what each SEP changes\, what breaks in the server you run today\, and what to refactor before the spec ships. I'll also show how we externalize session state at Mem0\, so a stateless server keeps the memory and context a real agent needs. \n \n You'll leave with a migration checklist and an architecture for stateless-first MCP.
CATEGORIES:MCPCON
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:3f7171581e71b1450ed3a20bb56b56a8
URL:http://agntconmcpconjapan26.sched.com/event/3f7171581e71b1450ed3a20bb56b56a8
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T014000Z
DTEND:20260910T020500Z
SUMMARY:Let AGENTS.md Write Itself: Self-Improving Coding Agents\, No RL Required! - Rudraksh Karpe\, Simplismart; Satyam Soni\, NitroStack
DESCRIPTION:AGENTS.md is the file that tells any coding agent how to work in your repo. One open AAIF standard\, read by Codex\, Cursor\, Claude Code\, and goose. But it is static. Written once\, by hand. It drifts as the code moves. Auto-generate it and agents often get worse\, following bloated rules and chasing dead paths. The agent fails the same way every run. Nothing feeds those failures back. The text that drives it never learns. \n \n This talk show how to fix that with a layer on top of AGENTS.md that tunes it from the agent's own runs.The loop is small. Run a task. Reflect on the trajectory in plain language. Find what broke. Propose one targeted edit. Validate it against an eval harness before it sticks. Reflect\, mutate\, validate\, select. Borrowed from reflective optimizers like GEPA. No RL. No fine-tuning. Just an agent learning from its mistakes. \n \n The layer is tool-agnostic because AGENTS.md is\, and it extends to MCP tool selection. We measure what moved\, task success\, edits per gain\, token cost\, regressions on a held-out set. We beat hand-written and auto-generated files. You leave with a layer you drop onto the AGENTS.md you already have.
CATEGORIES:BUILDING RELIABLE AGENT SYSTEMS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:a4a43e444b98a8b35f6e486068cf6326
URL:http://agntconmcpconjapan26.sched.com/event/a4a43e444b98a8b35f6e486068cf6326
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T014000Z
DTEND:20260910T020500Z
SUMMARY:MCP Auth: Am I Doing It Right? - Paul Carleton\, Anthropic
DESCRIPTION:Authorization in MCP has been through a number of revisions in the past year. Some major (remember when the authorization server and resource server were expected to be the same?) and some minor. As the specification has stabilized\, it can be difficult to know: Am I doing it right? \n \n In this talk we'll briefly recap where MCP Auth came from and where it is now\, and then we'll dig into Auth best practices based on evolving discussions and connecting Claude.ai to loads of MCP servers in practice. \n \n We'll cover things like: client registration\, progressive authz with challenges\, and enterprise managed auth to leverage existing SSO connections. \n \n We'll also explore the latest extensions in development and how to put them together into a cohesive solution for human-in-the-loop but also agentic and on-behalf-of flows. \n \n Lastly\, we'll cover how to leverage MCP's conformance testing suite to see how closely you're following best practices\, using either client\, server or authorization server test suites.
CATEGORIES:MCPCON
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:544fc19ab225296a98887c1653b2939a
URL:http://agntconmcpconjapan26.sched.com/event/544fc19ab225296a98887c1653b2939a
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T021500Z
DTEND:20260910T024000Z
SUMMARY:Carbon-Aware Agentic Engineering: Reducing Unnecessary Computation in AI Agent Workflows - Kouki Hama\, NTT\, Inc
DESCRIPTION: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. \n \n 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? \n \n The goal is not precise carbon accounting. Instead\, it identifies avoidable inference\, oversized context\, and needless tool calls before estimating CO2 emissions. \n \n Takeaways: \n * See how agent workflow design affects compute\, cost\, and latency. \n * Understand how reducing unnecessary computation supports green software goals. \n * Ask simple review questions to reduce unnecessary LLM calls\, retrieval\, memory\, and tool use.
CATEGORIES:AGENTIC ENGINEERING
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:f161704cb668d3bf03f257c0054740a4
URL:http://agntconmcpconjapan26.sched.com/event/f161704cb668d3bf03f257c0054740a4
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T021500Z
DTEND:20260910T024000Z
SUMMARY:MCP 2026-07-28 Under the Microscope: Security Implications for Stateless Agents - Thejes sree Satheesh kumar\, Thoughtworks & Srinivasan Sekar\, TestMu AI
DESCRIPTION:The MCP 2026-07-28 release candidate introduces a major shift in how agents connect\, authenticate and manage state. With a stateless protocol core\, first-class extensions and hardened authorization\, the new spec improves scalability and interoperability\, but it also changes the security model in ways that many builders may not fully anticipate. In this talk\, I will examine the release candidate through a defender’s lens and highlight the practical risks that emerge when session state disappears\, trust boundaries move and extension-based flexibility expands the attack surface. I will discuss failure modes such as broken state assumptions\, capability confusion\, unsafe cross-client behavior\, and authorization mistakes in real deployments. The session will also cover concrete hardening patterns for secure MCP adoption\, including least-privilege tool design\, explicit state handling\, authorization scoping\, telemetry and rollout validation. Attendees will leave with a practical checklist for evaluating stateless MCP systems and defending agent runtimes in production.
CATEGORIES:MCPCON
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:e0dc077a2909101bee32f543e840a63c
URL:http://agntconmcpconjapan26.sched.com/event/e0dc077a2909101bee32f543e840a63c
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T025000Z
DTEND:20260910T031500Z
SUMMARY:Letting an Agent Upgrade Production Kubernetes — Without Getting Paged at 3 AM - Sanskar Agrawalla & Abhijeet Chaudhuri\, Quartic.ai
DESCRIPTION:Kubernetes upgrades are high-stakes\, deprecation-laden\, and still mostly manual — most "AI for K8s upgrades" projects stop at a feasibility check. We went further: we built an agentic system that planned and executed a real cluster upgrade end to end\, and in this talk we walk through exactly how it went\, with the steps\, evidence\, and screenshots from our actual runs. \n \n We'll break down the architecture we shipped — a planner → executor → verifier loop\, deprecated-API and CRD/Helm compatibility analysis run before anything touched the cluster\, a human-in-the-loop approval gate for irreversible steps\, and health-gated automatic rollback. Using captured logs and screenshots\, we'll show a real multi-node upgrade as it happened\, the failure cases that nearly broke it (version skew\, stuck drains\, webhook deadlocks)\, and the decisions we deliberately refused to let the model make. \n \n You leave with an open-source blueprint for autonomous infra agents with production-grade guardrails — plus real numbers on success rate\, time saved\, preflight catches\, and rollbacks triggered.
CATEGORIES:BUILDING RELIABLE AGENT SYSTEMS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:9866047fd89179eb686758429b728be0
URL:http://agntconmcpconjapan26.sched.com/event/9866047fd89179eb686758429b728be0
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T031500Z
DTEND:20260910T043000Z
SUMMARY:Lunch (Provided Onsite)
DESCRIPTION:\n
CATEGORIES:SPECIAL EVENTS / EXHIBITS / BREAKS
LOCATION:Hall A\, Tokyo\, Japan
SEQUENCE:0
UID:60a84cfc7c649cde443ff4a01509f6a5
URL:http://agntconmcpconjapan26.sched.com/event/60a84cfc7c649cde443ff4a01509f6a5
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T043000Z
DTEND:20260910T045500Z
SUMMARY:Designing Trust Boundaries for Agent-to-Agent Systems: Lessons Learned from a Technical PoC - Ryuji Iijima\, Softbank Corp.
DESCRIPTION:As AI agents increasingly invoke tools\, access enterprise data\, and collaborate\, a new architectural challenge emerges: Where should trust boundaries be defined\, and where should governance and security controls be enforced?To explore this\, we conducted a technical PoC introducing a shared control layer across agent-to-agent communications and tool execution pathways. Rather than presenting an ideal architecture\, this session focuses on practical challenges and lessons learned during implementation.Key topics include:- Defining the "Agent": How to define what constitutes an agent in an ecosystem and where to establish trust boundaries for validation\, monitoring\, and control- Architectural Insights: Redesign considerations and insights that emerged through prototype development and PoC activities.- Performance Trade-offs: Balancing stronger security and governance with the low-latency requirements needed for real-world deployment.We will share practical takeaways on designing trust boundaries and navigating trade-offs among security\, governance\, and operational performance.
CATEGORIES:BUILDING RELIABLE AGENT SYSTEMS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:4092cdb971292a0fa06f1d6dc957bace
URL:http://agntconmcpconjapan26.sched.com/event/4092cdb971292a0fa06f1d6dc957bace
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T043000Z
DTEND:20260910T045500Z
SUMMARY:Do Tools Still Matter? MCP Tool Design in the Age of Code Mode - Ruben Casas\, Postman
DESCRIPTION:The first wave of MCP adoption was defined by abundance. Every API endpoint became a tool\, every workflow became a collection of tool calls\, and many servers exposed hundreds of operations directly to agents. It worked\, but at a cost: bloated context windows\, slower tool selection\, and increasingly unreliable agent behaviour. \n \n But then Code Mode appeared! \n \n With approaches Code Mode agents can search an API surface\, generate code\, and interact with services directly. If models can consume entire APIs and write code to acomplish a task\, does tool design still matter? \n \n In this talk\, we'll compare three approaches to agent tooling: curated workflow-oriented tools\, tool discovery and search\, and Code Mode's search-and-execute model. Using real-world examples\, benchmarks\, and evals\, we'll explore the trade-offs in reliability\, latency\, token usage\, and task success. \n \n Attendees will leave with a practical framework for deciding when to consolidate tools\, when to expose APIs\, and whether the future of MCP is better tools or fewer tools altogether.
CATEGORIES:MCPCON
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:095904e248a6a3e2e06f32dcea2f3ead
URL:http://agntconmcpconjapan26.sched.com/event/095904e248a6a3e2e06f32dcea2f3ead
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T043000Z
DTEND:20260910T060500Z
SUMMARY:Workshop: Governing AI Agent Actions: MCP and Beyond - Shannon Williams & Chris Urwin\, Obot AI
DESCRIPTION:Enterprise adoption of the Model Context Protocol is accelerating\, and MCP has become the primary way agents connect to enterprise tools and data. But MCP is only part of how agents act. Agents also run CLIs\, execute Skills\, and generate code that calls APIs directly. Governing MCP well matters. Governing everything else agents can do matters just as much.\n\nBuilding MCP servers and writing Skills isn't particularly hard. The real challenges are deciding which actions agents are allowed to take\, controlling who can take them\, and proving it all later. These are architectural questions\, and they need answers before agents scale across an organization.\n\nIn this workshop\, we will:\nShow how to control agent actions with policies that apply across MCP servers\, CLIs\, Skills\, and agent-generated code — including allowlists\, access control by users and groups\, and human-in-the-loop approvals.Explain why enterprises need managed registries for MCP servers and Skills\, and how admin review and approval change the trust model.Work through audit and compliance requirements: capturing complete logs of agent and tool activity\, exporting to enterprise storage\, and generating reports.⁠Demonstrate how to discover shadow AI — unmanaged agents\, MCPs\, and Skills already running in your organization — and how to block them or bring them under management.Look at token usage and spend visibility by agent\, user\, and group.\nYou'll leave with a clear picture of the architectural decisions ahead of you\, and a better sense of what your security team will require before signing off on scaling AI agents across your organization.
CATEGORIES:WORKSHOP
LOCATION:Hall B\, Tokyo\, Japan
SEQUENCE:0
UID:57422ba92b3b75e86563c6f13b65e1c7
URL:http://agntconmcpconjapan26.sched.com/event/57422ba92b3b75e86563c6f13b65e1c7
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T050500Z
DTEND:20260910T053000Z
SUMMARY:The Agent Builder Loop from Daily Work to OSS - Minoru Onda\, KDDI Agile Development Center Corporation
DESCRIPTION:AI agent discussions often focus on coding or MCP. My starting point is different. I use coding agents such as Claude Code and Codex as assistants for work beyond development. Instead of automating isolated tasks\, I keep them beside me as a secretary and knowledge platform for routine operations\, speaking requests\, internal coordination\, slide preparation\, and customer-facing project delivery.That daily use reveals agent-worthy problems. With Markdown\, Git\, Google Workspace\, and MCP in the loop\, work becomes context an agent can read\, improve\, and hand back. I then turn those problems into agents I build\, deploy\, review\, and operate myself.I will cover Vibe Presales\, my term for turning a customer's concerns\, constraints\, and reactions in a presales conversation into a working demo while the context is fresh. I will also share lessons from a PowerPoint-building agent\, including design\, deployment\, review\, and output quality for real slide and proposal work.These lessons become OSS code\, articles\, books\, and hands-on material. Attendees leave with a loop for living with agents at work\, building reliable systems\, and sharing reusable lessons.
CATEGORIES:BUILDING RELIABLE AGENT SYSTEMS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:581554fc8da1ac9f8ea9cde96851c8ec
URL:http://agntconmcpconjapan26.sched.com/event/581554fc8da1ac9f8ea9cde96851c8ec
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T050500Z
DTEND:20260910T053000Z
SUMMARY:MCP-Powered Crash Investigation: How 11 MCP Servers Help an AI Agent Debug Production Issues at Uber - Kriti Dangi\, Uber
DESCRIPTION:Debugging eats 42% of developer time — $300B lost globally every year. On an average\, fixing an issue takes 15 days. Debug Assist does it in 30 minutes — issue alert to validated\, reviewable PR.\n \n Most AI debugging tools stop at root cause analysis. Debug Assist goes much further: it writes a fix\, validates it in a loop till correct\, and creates the PR. Example\, It caught a crash at 5% rollout\, landed the fix the same day — preventing it from reaching thousands of users. Built on LangGraph with 11 MCP servers\, 5 plugins\, and parallel subagents: Sourcegraph for code search\, crash analytics\, Jira\, feature flags\, Jaeger\, and logging — all one protocol.\n \n Debug Assist even works on user-reported bugs which have minimal information attached. A user complained of battery drain\, and Debug Assist traced it to a hot-looping code path\, producing an RCA from behavioral evidence alone. \n Domain knowledge lives in markdown skill files in a plugin marketplace — any developer can contribute fix patterns with no code\, no redeployment.\n \n We'll share how we built this from ground up\, scaled to 5\,000 RCAs/month across 6 languages\, the challenges we hit\, and how we improved the acceptance rate from 5% to 30%
CATEGORIES:MCPCON
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:5e1fdc223eee63aaede83384ff2af232
URL:http://agntconmcpconjapan26.sched.com/event/5e1fdc223eee63aaede83384ff2af232
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T054000Z
DTEND:20260910T060500Z
SUMMARY:What Happens When Your MCP Tools Cost Money? - Prakash Rao\, AIG Technologies & Marco González\, Red Hat
DESCRIPTION:What happens when an AI agent has to pay for its tools? Today\, nobody knows. Open-source MCP servers run for free\, and their maintainers quietly absorb the cost. The x402 protocol changes the model: a server can charge a small payment for each tool call\, with no accounts or API keys needed. The plumbing works. The open question is how agents behave once tools have a price. \n \n We put it to the test. We ran a paid MCP server for several weeks and watched agents act as customers. We changed prices to find the point where agents stop calling a tool. We offered the same tool free and paid\, side by side\, to see whether agents compare prices or just call the first match. We let spending budgets run out mid-task to see what agents do when money gets tight. And we compared all of this across four agent clients: Google ADK\, LangGraph\, the OpenAI Agents SDK\, and Claude Code. \n \n The result is practical guidance for maintainers: what to charge\, where the payment flow breaks\, which framework behaviors to expect\, and whether per-call payments can realistically fund an open-source MCP server.
CATEGORIES:MCPCON
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:99cbe2175c5d17d3e0715d61421348e1
URL:http://agntconmcpconjapan26.sched.com/event/99cbe2175c5d17d3e0715d61421348e1
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T054000Z
DTEND:20260910T060500Z
SUMMARY:The Production Gap: Why Governing Agent Traffic Is the Key To Shipping Multi-Agent Systems - Juhi Singh\, Kong & Prithvi Raj\, Mirantis
DESCRIPTION:Every team building agentic systems hits the same wall: the gap between a demo and a system you'd trust in production. Most assume it's an engineering problem. It isn't. It's a governance problem and governance in a multi-agent system isn't a policy document. It's the full data path. \n \n We demonstrate a production-style multi-agent workflow where customer feedback flows through agents\, MCP tools\, GitHub integrations\, and multiple LLM providers before triggering automated actions. \n \n We show how cloud-native primitives govern every interaction: OpenTelemetry for distributed tracing across agent hops\, OPA for declarative policy enforcement\, API gateways for prompt injection protection and model routing\, and Kubernetes for workload isolation.\n \n The hardest part of running agents in production isn't the AI. It's the same problems Kubernetes solved for microservices\, observability\, traffic management\, policy\, workload isolation applied to a new class of workload the ecosystem is still learning to instrument. \n
CATEGORIES:MULTI-AGENT AND DISTRIBUTED SYSTEMS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:089aeb451c2d84affaa00b291b679699
URL:http://agntconmcpconjapan26.sched.com/event/089aeb451c2d84affaa00b291b679699
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T060500Z
DTEND:20260910T063500Z
SUMMARY:Coffee Break
DESCRIPTION:\n
CATEGORIES:SPECIAL EVENTS / EXHIBITS / BREAKS
LOCATION:Hall A\, Tokyo\, Japan
SEQUENCE:0
UID:b04cc8bf853c32c0200ab4dad34c6f38
URL:http://agntconmcpconjapan26.sched.com/event/b04cc8bf853c32c0200ab4dad34c6f38
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T063500Z
DTEND:20260910T070000Z
SUMMARY:Stop Giving Agents Tokens: Securing With Side-Car Proxies - Girish Motwani\, Microsoft & Ritwik Ranjan\, Microsoft
DESCRIPTION:As autonomous agents move from experimental scripts to production systems\, we’re exposing a massive flaw in how they’re built. We are giving LLMs the power to execute code\, access files\, and make network requests—essentially turning them into untrusted programs with direct authority over our infrastructure.\n \n Prompt injection isn’t just a model quirk\; it’s an open door to a massive attack surface. The moment an agent processes untrusted data\, that input can hijack generated code\, trigger outbound requests\, and lead to data leaks or Server-Side Request Forgery (SSRF). Without proper guardrails\, a highly capable agent is just a friendly interface over a Remote Code Execution (RCE) vulnerability.\n \n This session reframes the entire security challenge. Instead of wasting time trying to make the model perfectly "safe\," we’ll look at how to design infrastructure that stays secure even after the agent is compromised. By enforcing strict policy gates\, we ensure that even if an agent is hijacked\, it cannot access secrets\, traverse your network\, or execute privileged actions.
CATEGORIES:BUILDING RELIABLE AGENT SYSTEMS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:4feab9bcf3472e4eea0e079d3f5d931f
URL:http://agntconmcpconjapan26.sched.com/event/4feab9bcf3472e4eea0e079d3f5d931f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T063500Z
DTEND:20260910T070000Z
SUMMARY:Lessons From Building a Generative UI Runtime for MCP Apps - Rabi Guha\, Thesys Inc
DESCRIPTION:MCP UI lets servers return interactive application surfaces instead of plain tool results. But it raises a new question: what happens when the interface inside that surface is generated at runtime by the agent? \n \n This talk shares lessons from building a Generative UI layer within MCP UI. MCP UI provides the app/resource boundary and host communication model\, while frameworks like OpenUI provide the generated interface inside that boundary: a component registry\, model-friendly UI language\, streaming validation\, form state\, and explicit actions that route back to MCP tools. \n \n The key shift is that MCP UI does not have to mean one fixed widget per tool result. A server can expose capabilities and context\, the agent can generate the right interface for the task\, and the host can still control rendering\, permissions\, actions\, and observability. \n \n The demo uses a data-dashboard workflow: an agent connects to a datasource\, inspects data\, generates an interactive dashboard with filters and drilldowns\, then turns the result into persistent artifacts such as reports\, documents\, or slide decks.
CATEGORIES:MCPCON
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:0c36ddf3e8f586880fee6c124bffc0cd
URL:http://agntconmcpconjapan26.sched.com/event/0c36ddf3e8f586880fee6c124bffc0cd
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T063500Z
DTEND:20260910T081000Z
SUMMARY:Workshop: Getting Started with Goose & MCP Apps - Abhijay Jain\, AAIF Goose
DESCRIPTION:Whether you're new to Goose or just beginning your journey with MCP\, this hands-on workshop will help you get started with it. We'll walk through installing and configuring Goose\, explore the fundamentals of the Model Context Protocol (MCP)\, and demonstrate how to discover\, install\, and use MCP Apps to extend Goose with powerful new capabilities.\n\nThrough live demonstrations\, attendees will get a guided walkthrough of Goose\, learn how MCP Apps integrate with the platform\, and build a simple MCP-powered workflow that they can continue experimenting with after the session.\n\nBy the end of the workshop\, participants will have a working Goose setup\, understand how to use MCP Apps effectively\, and be equipped with the knowledge and resources to start building their own AI-powered workflows with Goose.
CATEGORIES:WORKSHOP
LOCATION:Hall B\, Tokyo\, Japan
SEQUENCE:0
UID:7810c77aaf74d1359b605f9eea2d5615
URL:http://agntconmcpconjapan26.sched.com/event/7810c77aaf74d1359b605f9eea2d5615
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T071000Z
DTEND:20260910T073500Z
SUMMARY:Your Platform Is Your Context: Scaling AI Agents With Platform Engineering - Gang Luo & Kristina Kondrashevich\, Electrolux
DESCRIPTION: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. \n \n 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. \n \n 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.
CATEGORIES:AGENTIC ENGINEERING
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:6f18181a21b641eca872849231d4501e
URL:http://agntconmcpconjapan26.sched.com/event/6f18181a21b641eca872849231d4501e
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T074500Z
DTEND:20260910T081000Z
SUMMARY:Intent as Code: Why Existing Permissions Aren’t Enough for AI - Masaya Nakamura\, Studist
DESCRIPTION:MCP grants AI agents access to file systems\, Git\, cloud\, and SaaS. Yet permission models — IAM\, OAuth scopes\, PATs — were built for humans and fall short for AI. \n \n The issue isn’t granularity. Existing permissions assume “human rationality” as a boundary: write access doesn’t mean a human wipes a repo\; CI write access doesn’t mean a human exfiltrates secrets. Permissions stay broad because human judgment fills the gap. AI lacks this buffer — through prompt injection or edge cases\, it acts destructively where a human would stop. Per-call approval collapses under fatigue. \n \n As an SRE on strong production credentials\, my question wasn’t “how to restrict AI” but “how to maximize safe delegation.” \n \n I propose Intent as Code: coding what was left to human rationality. Three OSS tools: \n safe-push rejects pushes touching .github/ or others’ commits\, preventing CI hijacking \n safe-gh wraps gh CLI with conditions like “only own issues” or “only approved PRs to develop” — expressing intent PATs can’t \n safe-webfetch uses Claude Code Hooks to auto-allow learned-safe URLs\, cutting fatigue decisions \n \n Attendees leave understanding why permissions fall short for AI\, with patterns to apply.
CATEGORIES:HUMAN-AGENT COLLABORATION
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:d55389764cb58147fe975fd809327269
URL:http://agntconmcpconjapan26.sched.com/event/d55389764cb58147fe975fd809327269
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T074500Z
DTEND:20260910T081000Z
SUMMARY:Running an MCP Proxy at Scale - Camila Rondinini\, Anthropic
DESCRIPTION:The MCP spec is clear about how one client and one server talk to each other. It says much less about what happens when the client is itself a distributed system\, serving millions of people across thousands of third-party MCP remote servers. \n \n At Anthropic\, we run a proxy between our products and a large\, growing set of remote servers. At that scale\, we started running into problems the spec doesn't answer. \n \n This talk is about three of them: \n \n - Authentication: How do we make authentication work across servers that all implement it a little differently? How do we keep people connected when connections drop and credentials expire\, without making them sign in again? \n \n - Caching: How do we avoid hammering the MCP remote servers\, and which caching strategies make that possible? \n \n - Monitoring: How do we monitor a system where the servers vary widely\, from stable production ones to unstable ones still in development? When something breaks\, how do we tell whether the fault is ours or the server's?
CATEGORIES:MCPCON
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:5bd428cac89d0748c7170d3f34da8b9f
URL:http://agntconmcpconjapan26.sched.com/event/5bd428cac89d0748c7170d3f34da8b9f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T082000Z
DTEND:20260910T084500Z
SUMMARY:Legacy Meets LLM: Giving Frontier Models a Telephone (PSTN) Over MCP - Shinya Saito\, Gen-AX Corp
DESCRIPTION:A web service exposes /health\; a phone line exposes nothing. The telephone is the oldest telecommunication tool still in production — and our LLM voice agents answer customer calls over it\, with no way to know whether they are answering\, hearing\, and behaving correctly right now. \n \n So we gave a frontier model a telephone. \n \n Our MCP server gives any LLM a phone: dial PSTN numbers\, speak via TTS\, and read the other side via silence-detected transcripts. A frontier model becomes the caller\, phoning our production voice agents in an agent-calls-agent loop — one mechanism covering the whole testing spectrum: ping-style health checks\, deep evaluation via scripted and adversarial conversations\, and load testing with concurrent caller fleets. \n \n We cover the MCP tool design for a domain the spec wasn't written for — tools that block for tens of seconds\, turn-taking over live audio\, per-call session state — where the spec fought us and what we would feed back\, plus what broke: timeout cascades and evaluations that flap. \n \n We are open-sourcing the server. You'll leave knowing how to connect your own agent to the PSTN — and how to ping\, probe\, and load-test anything that answers a phone.
CATEGORIES:MCPCON
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:b4f4bc58c96913ef40e14cf23d20cb7e
URL:http://agntconmcpconjapan26.sched.com/event/b4f4bc58c96913ef40e14cf23d20cb7e
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T082000Z
DTEND:20260910T084500Z
SUMMARY:Accelerating the Autonomous Web With WebMCP - Vin Lim\, StaffOS
DESCRIPTION:AI agents have long been capable of interacting with the web\, relying on brittle DOM scrapers and heavy browser automation has kept these workflows slow and prone to failure. We will explore how the WebMCP shifts agentic web interaction from merely functional to highly performant and efficient by providing a standardized\, machine-readable layer for context sharing and action execution. WebMCP eliminates the friction and overhead of legacy automation techniques.
CATEGORIES:PROTOCOLS & STANDARDS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:814d1a8ebf79d1dddd4827e135cfa9bc
URL:http://agntconmcpconjapan26.sched.com/event/814d1a8ebf79d1dddd4827e135cfa9bc
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T084500Z
DTEND:20260910T100000Z
SUMMARY:Sponsor Showcase
DESCRIPTION:\n
CATEGORIES:SPECIAL EVENTS / EXHIBITS / BREAKS
LOCATION:Hall A\, Tokyo\, Japan
SEQUENCE:0
UID:0ff74b36760abbf33fd1d31cb97957f6
URL:http://agntconmcpconjapan26.sched.com/event/0ff74b36760abbf33fd1d31cb97957f6
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260910T230000Z
DTEND:20260911T080000Z
SUMMARY:Registration & Badge Pick-Ip
DESCRIPTION:\n
CATEGORIES:SPECIAL EVENTS / EXHIBITS / BREAKS
LOCATION:B1F Foyer (Outside Hall C)\, Tokyo\, Japan
SEQUENCE:0
UID:a5cdd25f0e8673f9665fbfc6f7b9cf63
URL:http://agntconmcpconjapan26.sched.com/event/a5cdd25f0e8673f9665fbfc6f7b9cf63
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T000000Z
DTEND:20260911T001000Z
SUMMARY:Keynote: Welcome - Mazin Gilbert\, Executive Director\, The Agentic AI Foundation
DESCRIPTION:\n
CATEGORIES:KEYNOTE SESSIONS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:67d6cdeadcfdaeece38f55f912d47d7d
URL:http://agntconmcpconjapan26.sched.com/event/67d6cdeadcfdaeece38f55f912d47d7d
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T001000Z
DTEND:20260911T002000Z
SUMMARY:Keynote Session to be Announced
DESCRIPTION:\n
CATEGORIES:KEYNOTE SESSIONS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:f1743b63407948d9544d2918f6bd0da5
URL:http://agntconmcpconjapan26.sched.com/event/f1743b63407948d9544d2918f6bd0da5
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T002500Z
DTEND:20260911T003500Z
SUMMARY:Keynote: Skills Over MCP: From Experiment to Extension - Ola Hungerford\, Principal Engineer\, Nordstrom
DESCRIPTION:Tool descriptions tell an agent what a tool can do\, but not how to orchestrate those capabilities toward a goal\, or supplement them with specialized knowledge. Agent skills have become a popular and accessible way to close that gap\, and many organizations now ship skills alongside their servers. The community effort to standardize that pairing has drawn 50+ contributors from 25+ organizations across the entire AI infrastructure stack: cloud platforms\, data platforms\, enterprise SaaS\, gateways\, and independent implementers. This talk covers where that momentum is headed\, and how Extensions let the protocol evolve to meet real-world demand while balancing the stability\, security\, and developer experience that production systems require.
CATEGORIES:KEYNOTE SESSIONS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:a178f6bc34c6bcda7bbc41174d097182
URL:http://agntconmcpconjapan26.sched.com/event/a178f6bc34c6bcda7bbc41174d097182
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T004000Z
DTEND:20260911T004500Z
SUMMARY:Keynote: Manik Surtani\, Chief Technology Officer\, The Agentic AI Foundation & Paul Conyngham\, Founder\, Gamgee
DESCRIPTION:\n
CATEGORIES:KEYNOTE SESSIONS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:4a480fcd09688039933658a5839267ec
URL:http://agntconmcpconjapan26.sched.com/event/4a480fcd09688039933658a5839267ec
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T004500Z
DTEND:20260911T010500Z
SUMMARY:Coffee Break
DESCRIPTION:\n
CATEGORIES:SPECIAL EVENTS / EXHIBITS / BREAKS
LOCATION:Hall A\, Tokyo\, Japan
SEQUENCE:0
UID:2edf4e830a6a220e278812f3ddde67c8
URL:http://agntconmcpconjapan26.sched.com/event/2edf4e830a6a220e278812f3ddde67c8
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T010500Z
DTEND:20260911T013000Z
SUMMARY:One Proxy To Rule Them All: MCP\, LLM\, and A2A - Bharath Nallapeta\, Mirantis Inc.
DESCRIPTION:A working agent ends up talking to a lot of things: a handful of MCP servers\, two or three LLM providers\, maybe another agent. Each one is a separate integration you wired in yourself\, with its own auth and its own logging\, or its own lack of it. Nothing sees all of it at once. \n \n agentgateway is trying to be the thing that does. It's an open-source Rust proxy\, an Agentic AI Foundation project as of this year\, that sits in front of MCP\, LLM\, and A2A traffic together. The talk is mostly the gateway running on screen. \n \n Four separate MCP servers go behind one endpoint and show up to the agent as a single list of tools. Claude Code connects to that one address and never finds out the tools live in four different places. One short rule\, and a tool you don't want exposed stops showing up at all: not blocked\, just never offered. Point the model traffic through the same gateway and a provider can drop mid-demo without the agent noticing\, the whole thing readable as one trace. \n \n Underneath the protocols\, the idea is simple: an agent reaching into the world should go through one door someone is watching\, not a hundred that nobody is. Building that door is what the talk is about.
CATEGORIES:PROTOCOLS & STANDARDS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:0a4e6373d8d31d70779ab68e95755fc2
URL:http://agntconmcpconjapan26.sched.com/event/0a4e6373d8d31d70779ab68e95755fc2
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T010500Z
DTEND:20260911T013000Z
SUMMARY:Skills as Reusable Operational Knowledge - Nimit Savant\, DevRev
DESCRIPTION:The next leap in agent engineering is not bigger models. It's reusable skills. \n \n Today\, many agents repeatedly spend tokens rediscovering the same workflow every time a task appears. Whether it's code reviews\, incident analysis\, documentation generation\, or research tasks\, the agent often re-plans work it has already solved before. \n \n This talk explores how agent skills are emerging as reusable workflow primitives that package expertise\, decision-making patterns\, and execution steps into portable capabilities. Instead of relying on increasingly large prompts\, teams can teach agents repeatable workflows once and reuse them across tasks\, products\, and environments. \n \n \n Key Takeaways \n \n - Why prompts don't scale for repetitive work \n - Skills as reusable workflow contracts \n - Reducing token consumption through workflow reuse \n - How skills and MCP work together \n - Building self-improving agent systems
CATEGORIES:PROTOCOLS & STANDARDS
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:9b985fad78b04ef54989a604fd447f54
URL:http://agntconmcpconjapan26.sched.com/event/9b985fad78b04ef54989a604fd447f54
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T014000Z
DTEND:20260911T020500Z
SUMMARY:How I Built the Most Viral Agentmemory Completely Opensource With 22K+ GitHub Stars - Rohit Ghumare\, iii & Vinuja Khatode\, JP Morgan Chase
DESCRIPTION: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. \n \n 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 \n 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. \n \n 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. \n \n 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.
CATEGORIES:AGENTIC ENGINEERING
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:4481d03e6e0e4242069fbbcaa2b0e7ff
URL:http://agntconmcpconjapan26.sched.com/event/4481d03e6e0e4242069fbbcaa2b0e7ff
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T014000Z
DTEND:20260911T020500Z
SUMMARY:You Have 1000 Employees and None of Them Have a Name - Marcus Tenorio\, Bitso
DESCRIPTION:Your agent swarm is running. It's browsing the web\, calling APIs\, reading files\, making decisions\, all on behalf of your users and your organisation. But ask yourself: do you know which agent did what? Can you revoke access to just one of them? Can you prove to an auditor that your agents only touched what they were supposed to? \n \n Probably not. Because most agentic deployments treat agents as anonymous processes : no identity\, no credentials\, no audit trail\, no way to fire them when something goes wrong. If a human employee operated this way\, you'd call security. For agents\, we call it production.\n \n This talk proposes a fundamentally different approach: onboard your agents like employees. Every agent in your swarm deserves a verifiable identity\, scoped permissions\, a centralised audit trail\, and an offboarding process. Drawing from experience securing cloud native and AI infrastructure\, this session presents a blueprint for an open source "Okta for agents"! composing Identity Providers\, API gateways\, and policy engines to bring the same governance we give humans to the systems acting on their behalf.\n \n You hired 1000 people. It's time to learn their names.
CATEGORIES:HUMAN-AGENT COLLABORATION
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:b4e71d1bbc35546d13f5ce84407141ed
URL:http://agntconmcpconjapan26.sched.com/event/b4e71d1bbc35546d13f5ce84407141ed
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T021500Z
DTEND:20260911T024000Z
SUMMARY:The 3 AM Page: Turning Chaos Into Context With Bounded AI and Structured Evidence - Madhu Patel & Sudhanshu Sah\, Adobe
DESCRIPTION:AI-powered incident response sounds like the perfect use case for autonomous agents\, but giving them unrestricted access to raw alerts and logs can quickly turn automation into hallucination. Whether you're debugging production outages or investigating failed deployments\, engineers still spend hours manually correlating signals across disconnected observability tools.\n \n In this talk\, we'll break down the anatomy of a reliable agentic incident investigation system and show why structured incident context outperforms raw telemetry\, how evidence enrichment improves reasoning\, and why bounded context is critical for trustworthy AI agents. \n \n We'll walk through production-ready patterns for building dependable operational agents: \n 1. Structured evidence gathering from Datadog\, New Relic\, Splunk\, and Prometheus \n 2. Context engineering through alert correlation and deployment metadata \n 3. Long-term memory using historical incidents stored in a vector database \n 4. Human-agent collaboration that validates AI-generated RCAs and continuously improves future investigations. \n \n Thus helping you reduce manual triage\, lower MTTR\, and build reliable\, production-ready AI-driven incident response systems.
CATEGORIES:BUILDING RELIABLE AGENT SYSTEMS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:10bd08f3a06d5fc40e584fc12ba1315e
URL:http://agntconmcpconjapan26.sched.com/event/10bd08f3a06d5fc40e584fc12ba1315e
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T021500Z
DTEND:20260911T024000Z
SUMMARY:The Primitive AI Agents Are Missing: Graph-Based Code Intelligence - John Interlante\, Aleutian AI
DESCRIPTION:Graph-based code intelligence (not GraphRAG) is the infrastructure primitive that AI coding agents need to reason about large codebases without burning tokens. In this session\, we'll evaluate various approaches and identify where the field is converging. \n \n Agents fall back to grep because retrieval solutions return a probabilistic approximation of the code at a given point in time. The context goes stale on changes and loses fidelity when going from code to embeddings. By exposing a call graph\, based on established compiler theory\, to the LLM through a series of functions and tools\, the LLM doesn't need to waste tokens because it has access to deterministic\, structured\, quick access data from which it can get cheap\, reliable answers. \n \n Sourcegraph\, Meta's Glean\, Google's Kythe\, GitHub's Stack Graphs\, and newer efforts like GitNexus and Aleutian Trace are all building graph based offerings for LLMs. This session provides a deep dive into the problems faced by agents working in large codebases\, maps the solution space of graph based coding tools vs more common LLM solutions— RAG\, GraphRAG\, pure traversal\, embeddings — and then shows where each wins or breaks.
CATEGORIES:BUILDING RELIABLE AGENT SYSTEMS
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:7a1d72d2fec212f2e0c5e3b00ed08ad5
URL:http://agntconmcpconjapan26.sched.com/event/7a1d72d2fec212f2e0c5e3b00ed08ad5
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T025000Z
DTEND:20260911T031500Z
SUMMARY:Your Agent Starts the Checkout. Then What? - Muskan Jain\, Independent
DESCRIPTION:Modern agent workflows rarely finish in a single tool call. Commerce\, travel\, healthcare\, and enterprise operations all require multi-step\, stateful\, failure-prone transactions that span agents\, tools\, and time. MCP today excels at stateless tool invocation\, but production systems demand more: resumability\, idempotency\, compensation\, human-in-the-loop\, and trust boundaries. \n In this talk\, we present a Stateful MCP architecture for long-running transactions\, using Universal Commerce Protocol (UCP) checkout flows as a real-world case study. We’ll walk through patterns for durable context\, agent coordination\, transaction lifecycles\, rollback strategies\, and human approvals\, and show how MCP can serve as the orchestration layer for multi-agent workflows that behave more like distributed systems than chatbots.
CATEGORIES:AGENTIC PAYMENTS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:f08b8c94deba17b35f773c8c73e5bb2b
URL:http://agntconmcpconjapan26.sched.com/event/f08b8c94deba17b35f773c8c73e5bb2b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T025000Z
DTEND:20260911T031500Z
SUMMARY:The Model and the Mask: An Actor's Method for Engineering Agent Character - Nick Howden-Steenstra\, Independent
DESCRIPTION:Every agent system is two things: the model\, which you rent\, and the mask - the character - which is yours. The industry keeps upgrading the model and expecting the mask to improve. It doesn't work that way. \n \n I'm a LAMDA-trained actor turned agent engineer. This talk is the actor's toolkit applied to shipped systems. Case one: a comms pipeline in production at a major crypto protocol - the generating model does Stanislavski table-work (super-objective\, through-action\, lining) before writing a word\; a separate director model audits it blind\; and voice is scored by a Laban Movement Analysis classifier that grades the human-written corpus and the machine's output on the same instrument. Brand voice becomes a falsifiable measurement. Case two: the home lab - eleven agents built with a Stanislavski character method\, orchestrated over MCP\, running my actual work. \n \n You'll leave with the model/mask distinction\, a character pipeline you can copy\, and the failure modes: drift\, voice collapse\, paint-by-numbers slop.
CATEGORIES:HUMAN-AGENT COLLABORATION
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:85df2a26bc58bd1c657bad01f9037f4c
URL:http://agntconmcpconjapan26.sched.com/event/85df2a26bc58bd1c657bad01f9037f4c
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T031500Z
DTEND:20260911T043000Z
SUMMARY:Lunch (Provided Onsite)
DESCRIPTION:\n
CATEGORIES:SPECIAL EVENTS / EXHIBITS / BREAKS
LOCATION:Hall A\, Tokyo\, Japan
SEQUENCE:0
UID:efba68d2a4664953aa3cbc2e55ceaf7c
URL:http://agntconmcpconjapan26.sched.com/event/efba68d2a4664953aa3cbc2e55ceaf7c
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T043000Z
DTEND:20260911T045500Z
SUMMARY:Stateful Sandboxes for Stateless Agents: Designing Durable Volumes for MCP Tool Workspaces - Weiwei Zhu\, Juicedata
DESCRIPTION:Agent sandboxes are often described as ephemeral\, but real MCP tool workflows are not. Agents edit files\, install dependencies\, run tests\, download inputs\, generate reports\, and resume after failures. When workspace state is treated as disposable\, reproducibility\, isolation\, and debugging become unnecessarily painful. \n \n This talk presents a practical framework for designing durable volumes in agent sandboxes. Through a structured checklist — covering lifecycle management\, tenant isolation\, quotas\, snapshots\, read-only sharing\, dependency caches\, artifact retention\, remount recovery\, and audit trails — attendees will learn how to reason about workspace state systematically. \n \n We then map these requirements to Kubernetes PersistentVolumes and explore the tradeoffs using JuiceFS CSI as a concrete open-source example. JuiceFS is used for its strong Kubernetes integration and snapshot capabilities\, though the framework applies equally to local containers\, serverless environments\, and remote tool sandboxes.
CATEGORIES:BUILDING RELIABLE AGENT SYSTEMS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:a1dac74a16f3dace275617ec4c3e12c1
URL:http://agntconmcpconjapan26.sched.com/event/a1dac74a16f3dace275617ec4c3e12c1
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T043000Z
DTEND:20260911T045500Z
SUMMARY:From Clicks To Context: Building an Open-Source Evaluation Pipeline for AI Agents - Inês Bolaños\, PagerDuty
DESCRIPTION:The AI industry has moved so fast that we are still evaluating probabilistic software using the same deterministic metrics we applied to traditional code. As a Product Analyst working on AI agents at PagerDuty\, I saw a critical need for a new observability standard\, one that moves beyond clicks to measure true reasoning and reliability. To address this\, I’ve developed and open-sourced a specialized framework designed to help teams decide\, with data\, when to hire\, train\, or fire an AI agent. In this session\, I will walk through the H.I.R.E. Framework methodology and share the technical architecture of an evaluation pipeline that turns qualitative conversational data into structured\, actionable product insights. I will share the open-source repository containing these metric definitions and templates\, providing resources for the community to move past agent-washing and toward building verifiable\, trustworthy agentic systems.
CATEGORIES:EVALUATION & TESTING
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:e7cca4d1f54433ed02ddce94778278e5
URL:http://agntconmcpconjapan26.sched.com/event/e7cca4d1f54433ed02ddce94778278e5
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T050500Z
DTEND:20260911T053000Z
SUMMARY:What's Actually Running in Your Coding Agent: The Shadow AI Stack - Alexander Frazer\, Runlayer
DESCRIPTION:"Every MCP server\, skill\, and plugin in your coding agent is code or instructions you never really reviewed\, running with your access to your database\, your repos\, and your keys. Three different ways in\, and almost nobody is watching any of them." \n \n Most of the agent security conversation is about prompt injection. Meanwhile there are three underserved vectors sitting right inside the tools you use every day: \n \n - **MCP servers** run with the same access you have. One can look clean when you approve it and change its behavior later\, or pull in a compromised dependency on the next run. \n - **Skills and instruction files** (`SKILL.md`\, `AGENTS.md`\, `CLAUDE.md`\, rules files) are just text. Nothing to install\, nothing to flag. They quietly reshape what your agent does\, and hidden instructions\, zero-width characters\, and pipe-to-shell tricks ride in the same way. \n - **Plugins** bundle the first two together and ship through marketplaces with uneven vetting\, so a single install can bring in both an MCP server and a skill you never opened. \n \n I'll show where each one lives on disk\, why the usual tooling misses it.
CATEGORIES:BUILDING RELIABLE AGENT SYSTEMS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:e00fa34f4c3d0f7a0b5167579626c08f
URL:http://agntconmcpconjapan26.sched.com/event/e00fa34f4c3d0f7a0b5167579626c08f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T050500Z
DTEND:20260911T053000Z
SUMMARY:What's Missing in the Open Agentic Stack: Lessons From OSS Integration - Tatsuya Sato & Satoshi Ito\, Hitachi\, Ltd.
DESCRIPTION:In the agentic AI space\, standards like MCP and A2A and a growing OSS ecosystem are evolving. Yet building a real multi-agent system requires more than a single framework or protocol. It involves integrating multiple OSS components and adjacent specifications across areas such as agent-to-agent communication\, orchestration\, authentication\, and observability. There is limited shared understanding of how to combine them and what architectural considerations and integration gaps emerge. \n \n This session shares our work on organizing the landscape of OSS-based agentic AI stacks\, and on designing architectures built around MCP\, A2A\, and representative OSS\, including prototyping through reference implementations. We explore several architectural patterns from a whole-system perspective. With enterprise use in mind\, our scope also covers cross-cutting concerns such as authentication and observability. (LLMs are currently proprietary.) \n \n Through this work\, we examine what each OSS layer solves and does not solve\, and highlight cross-layer concerns that emerge only when components are integrated as a multi-agent system. We share these observations with a demo of the reference implementation.
CATEGORIES:OPEN INFRASTRUCTURE AND TOOLING
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:e145c0e5cef496d3f52547f3f1a6b0bd
URL:http://agntconmcpconjapan26.sched.com/event/e145c0e5cef496d3f52547f3f1a6b0bd
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T054000Z
DTEND:20260911T060500Z
SUMMARY:Building an Agentic Software Factory - Valentin De Matos\, Delphi
DESCRIPTION: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. \n \n 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. \n \n Attendees will leave with a practical blueprint for moving from “agent writes code” to a controlled delivery pipeline for agent-generated software
CATEGORIES:AGENTIC ENGINEERING
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:5e78fd139403b29d7f21906317430181
URL:http://agntconmcpconjapan26.sched.com/event/5e78fd139403b29d7f21906317430181
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T054000Z
DTEND:20260911T060500Z
SUMMARY:The Conductor Pattern: Multi-Granularity Feedback for Creative Agents - Yusuke Shibui\, MLOps/LLMOps/AgentOps Community
DESCRIPTION:Most "human-in-the-loop" agent systems assume the human can specify success up front: a passing test\, green CI\, a structured eval. What if the human's taste is the spec?\n \n This talk presents YouAndOrchestra (YaO)\, an open-source agentic music composition system on Claude Code. YaO orchestrates seven role-based subagents — Producer\, Composer\, Harmony Theorist\, Rhythm Architect\, Orchestrator\, Mix Engineer\, Adversarial Critic — turning natural language into a score evaluated across six dimensions\, every note carrying provenance.\n \n https://github.com/shibuiwilliam/YouAndOrchestra \n \n Three collaboration patterns from iteration: \n 1. Three-tier feedback. Users rewrite the YAML spec\, regenerate a section\, or pin feedback to a bar\, beat\, and instrument. Choosing the level is itself a UX problem. \n 2. Conductor loop with a critic gate. Generate\, evaluate\, adapt\, regenerate runs up to three iterations\, with critics gating before notes are placed. \n 3. Provenance as trust substrate. /explain queries an append-only causal graph — "why did the chorus modulate to the relative minor?" \n \n Attendees leave with patterns and open-source code for agent systems where the human stays in the seat of judgment.
CATEGORIES:HUMAN-AGENT COLLABORATION
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:36f7c994a4de77ca2c7d53a61896d482
URL:http://agntconmcpconjapan26.sched.com/event/36f7c994a4de77ca2c7d53a61896d482
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T060500Z
DTEND:20260911T063500Z
SUMMARY:Coffee Break
DESCRIPTION:\n
CATEGORIES:SPECIAL EVENTS / EXHIBITS / BREAKS
LOCATION:Hall A\, Tokyo\, Japan
SEQUENCE:0
UID:ee9cef071a1c4d970c5f442285ed90dd
URL:http://agntconmcpconjapan26.sched.com/event/ee9cef071a1c4d970c5f442285ed90dd
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T063500Z
DTEND:20260911T070000Z
SUMMARY:Governed Agent Autonomy: Building a Control Plane for Agentic Systems - Nnenna Ndukwe\, Qodo AI
DESCRIPTION:We see how quickly AI coding tools and agent harnesses are improving. But how can the surrounding system keep that autonomy governable once an agent starts planning\, executing tools\, changing files\, and consuming budget on a team’s behalf? \n \n In this talk\, I break down a technical case study based on a real AI coding control-plane architecture and show how serious systems structure autonomy through explicit boundaries: plan gates\, permission controls\, trust review\, independent verification\, and runtime observability. I will walk through the patterns and production-grade examples\, explain why telemetry and quota tracing are integral to code governance\, and show why integrity failures can still happen even with strong coding workflows. \n \n This session gives engineering leaders and practitioners a framework for evaluating AI coding tools. The goal is to achieve agent governance that teams can trust\, audit\, and scale.
CATEGORIES:BUILDING RELIABLE AGENT SYSTEMS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:08aca0b2bce2fb3dc069a82abff63eb6
URL:http://agntconmcpconjapan26.sched.com/event/08aca0b2bce2fb3dc069a82abff63eb6
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T063500Z
DTEND:20260911T070000Z
SUMMARY:Built for Two: What Design Systems Are Missing When AI Agents Become the Third User - Karen Ng\, Endor Labs
DESCRIPTION:AI coding agents now generate UI from component libraries. Most teams write component markdown files and expect agents to take it from there. The docs were complete. Agents still got it wrong. \n \n Sitting with engineers in code review\, the same things kept surfacing: the agent picked a visually similar but wrong component\; it invented props\; it read "Tag" as a UI primitive when the codebase meant a security concept. One author. No review process. A library too large for any agent to navigate without a map. \n \n Not a component library talk. A talk about what the workflow was missing when the docs were already done. \n \n I'll walk through the workflow that came out of those sessions: why a component file needs more than one author before agents can trust it\; how an index changes what agents can find\; and the naming decision that was invisible to humans and catastrophic for agents. Including the moment the team realized the problem wasn't the docs. \n \n You'll leave with one reframe: a component library has always had two users. It now has a third. Here is what the workflow looks like when you build for all three.
CATEGORIES:HUMAN-AGENT COLLABORATION
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:f8bef39551bf11be62b60d1b255ec724
URL:http://agntconmcpconjapan26.sched.com/event/f8bef39551bf11be62b60d1b255ec724
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T071000Z
DTEND:20260911T073500Z
SUMMARY:Beyond Prototypes: Building Enterprise-scale Agentic Systems - Kevin Dubois\, IBM & Mauricio "Salaboy" Salatino\, Dash0
DESCRIPTION:There has been a lot of progress in agentic frameworks (such as Langchain\, CrewAI\, Autogen\, among others)\, most of them written in and targeting Python developers. These frameworks allow you to build multi-agent systems that are co-located inside the same application. \n \n That works well for fast experimentation and building prototypes\, but production systems live or die on scalability\, security\, observability and governance. At the end of the day agents are software that we need to ship\, run an operate on production\, much like any other type of enterprise software. \n \n In this session we will show how to build distributed agentic\, MCP-connected systems that are ready for enterprise scale. We'll cover real production patterns such as agentic orchestration patterns\, MCP interoperability\, agent/tool coordination\, observability and tracing and enterprise integration reusing our existing platforms.
CATEGORIES:MULTI-AGENT AND DISTRIBUTED SYSTEMS
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:e87046bb9471e8199f68dc0a6c9a9df2
URL:http://agntconmcpconjapan26.sched.com/event/e87046bb9471e8199f68dc0a6c9a9df2
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T071000Z
DTEND:20260911T073500Z
SUMMARY:Build Your Own Open-Source Claude Code With Local LLMs - Daniel Oh\, Red Hat
DESCRIPTION:AI coding assistants are becoming part of everyday development\, but many enterprises cannot send source code\, internal APIs\, or project context to external services. They need the productivity of coding agents while keeping models\, repositories\, prompts\, and actions under their control. \n \n In this session\, we’ll show how to build an open-source\, Claude Code-like assistant using local or privately hosted LLMs\, Models as a Service\, OpenCode\, and AI guardrails. Developers will be able to explore a codebase\, generate changes\, review explanations\, and trigger controlled actions without exposing sensitive data. \n \n We’ll also cover the guardrails needed for real use: secrets protection\, data leakage checks\, unsafe command blocking\, insecure code detection\, and policy-based action control. \n \n You’ll leave with a practical blueprint for building a private\, secure coding assistant that improves developer productivity without compromising trust\, privacy\, or compliance.
CATEGORIES:OPEN INFRASTRUCTURE AND TOOLING
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:e86c1a85882056a62752e8edd337e7c1
URL:http://agntconmcpconjapan26.sched.com/event/e86c1a85882056a62752e8edd337e7c1
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T074500Z
DTEND:20260911T081000Z
SUMMARY:Why Traditional AI Benchmarks Fail Voice Agents - Harshita Jain\, Smallest AI
DESCRIPTION:AI systems are increasingly evaluated using benchmarks designed for individual components: Word Error Rate (WER) for speech recognition\, MOS for speech synthesis\, latency for infrastructure\, and task success for agents. Yet users experience none of these components in isolation when using voice agents\, they experience conversations. \n \n Voice agents expose the limitations of traditional evaluation more clearly than any other AI system. An agent can achieve state-of-the-art WER\, MOS\, and latency metrics while still delivering a frustrating user experience. \n \n This talk explores why established metrics are becoming insufficient for real-time AI applications and introduces a framework for evaluating voice agents holistically. We will examine concepts such as semantic understanding versus transcription accuracy\, latency distributions versus averages\, interruption handling\, recovery from errors\, and conversation-level success metrics. \n \n Through real-world examples from production voice systems\, attendees will learn how to move beyond component benchmarks and begin measuring what ultimately matters: whether an AI system successfully helps a user achieve their goal.
CATEGORIES:EVALUATION & TESTING
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:8fa17ac1a178bde977aedc7fe742aade
URL:http://agntconmcpconjapan26.sched.com/event/8fa17ac1a178bde977aedc7fe742aade
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T074500Z
DTEND:20260911T081000Z
SUMMARY:Externalizing Agent State: Memory and Filesystem Management for Sandboxed Coding Agents - Tadatoshi Sekiguchi\, PingCAP
DESCRIPTION:Coding-agent harnesses such as Claude Code\, Codex\, and OpenCode are widely used as general-purpose agent platforms\, customized with Skills and Tools and run inside sandboxes. But these agents are stateless by design: when a session ends or a sandbox is torn down\, context and artifacts disappear. Running them in production for many users over months turns memory and artifact management into hard problems. \n \n This session shares how we run multiple harness-based agents in sandboxes\, and introduces two open-source tools we built to externalize agent state. mem9 (github.com/mem9-ai/mem9) records sessions through harness hooks and\, at the next session\, runs hybrid retrieval over past sessions from the user's instruction\, injecting only relevant history—persisting sessions while compressing context and cutting token usage. drive9 (github.com/mem9-ai/drive9) is a cloud filesystem FUSE-mounted into each sandbox\, persisting artifacts beyond sandbox lifetimes\, auto-attaching metadata\, and enabling semantic search over outputs. \n \n Attendees will leave with a vendor-neutral\, open-source architecture for agent memory and storage that works across any harness\, plus lessons from real operation.
CATEGORIES:OPEN INFRASTRUCTURE AND TOOLING
LOCATION:Hall 1F\, Tokyo\, Japan
SEQUENCE:0
UID:a8e3a597e8cf61784d82861a8e2116bf
URL:http://agntconmcpconjapan26.sched.com/event/a8e3a597e8cf61784d82861a8e2116bf
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260726T225347Z
DTSTART:20260911T082000Z
DTEND:20260911T084500Z
SUMMARY:Your Agent Inherits Code\, Not Decisions: How To Use Context Graphs for Intent - Nyah Macklin\, Neo4j
DESCRIPTION: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.\n \n 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.\n \n 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.\n \n You'll leave with patterns for making the why available to every agent that touches your work.
CATEGORIES:AGENTIC ENGINEERING
LOCATION:Hall C\, Tokyo\, Japan
SEQUENCE:0
UID:d1586ec6584e6be8c6a370eb6d6239cb
URL:http://agntconmcpconjapan26.sched.com/event/d1586ec6584e6be8c6a370eb6d6239cb
END:VEVENT
END:VCALENDAR