QCon AI New York 2026: Agent Identity, Context Costs, and Open-Source Inference Signal the End of the AI Demo Era

Every big tech conference tells you what people are excited about. The ones worth watching tell you what people are struggling with. That is the real value of the QCon AI New York 2026 program committee picks, announced October 29, 2026. The committee's chosen themes, agent identity, context costs, and open-source inference, are not shiny new model announcements. They are the three walls that every team building real AI products has slammed into over the past year.

That shift matters. When a program committee stops picking talks about what models can do and starts picking talks about how to run them safely, cheaply, and on your own terms, it means the industry has crossed a line. The era of the impressive demo is ending. The era of the hard operational work has begun.

Here is what each of those three themes really means, why they landed together on the same agenda, and what leaders should do about it now.

Agent Identity: Your AI Is Now a Coworker With a Login

For most of the last few years, an AI model was something you called. You sent a request, you got a response, and nothing persisted. Agents changed that. An agent can hold a session, remember what it did yesterday, call other systems, and take actions on its own, book the ticket, file the report, move the money, send the email.

The moment software can act, it needs an identity. Not a nice-to-have identity. A real one: a credential, a permission set, an audit trail, and an owner who is accountable when things go wrong.

This is where the cracks show in nearly every enterprise pilot. Consider a simple question a security team will eventually ask: when an agent deletes a record, whose name is on it? If the answer is "the service account" or "the developer's API key," you have a problem. You cannot review, revoke, or reason about an action you cannot attribute to a specific agent acting on behalf of a specific person for a specific reason.

The three questions every agent program must answer

• Who is this agent acting for? An agent working for a finance analyst should not carry the same permissions as one working for an intern. Delegated authority has to be explicit, scoped, and time-limited.
• What is it allowed to touch? The default for agents should be the smallest possible surface. Read-only unless a human or a policy grants more. Most agent failures are permission failures that nobody noticed at design time.
• How do you prove what happened? Audit logs are not optional once an agent can transact. If you cannot reconstruct the chain of decisions, you cannot insure, defend, or improve the system.

There is a harder, human side to this too. As agents take on more delegated work, the question of trust boundaries becomes a product design problem, not just a security one. Users need to feel the difference between what the agent did and what it merely suggested. That means visible confirmation steps for high-impact actions, clear labeling of AI-generated work, and a way to roll back. Identity is not only about credentials, it is about the honesty of the interface.

Expect this theme to drive a wave of tooling: agent registries, scoped token services, policy engines that speak in human rules rather than code, and audit dashboards built specifically for non-deterministic software. The teams that invest here early will ship faster later, because security review stops being a six-month roadblock.

Context Costs: The Bill Nobody Budgeted For

Second on the committee's list is something that sounds boring and turns out to be existential: context costs.

Here is the plain version. AI models have a working memory, a "context window", where you put the instructions, documents, chat history, and tool results the model needs to answer well. Early on, everyone treated that space as free. Just cram in more. Paste the whole policy manual. Attach the entire conversation. Let the agent remember everything forever.

It is not free. Every token you push into that window costs money on every single call. It costs latency, so users wait longer. And it costs quality, because models get worse at finding the needle when you bury it in hay, the well-known problem where important details in the middle of a long input get ignored.

The result is a pattern that has burned a lot of budgets: an agent that works beautifully in a demo, then scales to thousands of daily users and produces a monthly bill that makes the finance team ask very direct questions. Worse, the same agent may quietly perform worse at scale, because its context has become a junk drawer of stale history.

What good context engineering looks like

• Retrieve, do not dump. Pull the three relevant paragraphs instead of attaching the 300-page document. Precision beats volume.
• Summarize as you go. Compress old conversation into a short structured memory rather than replaying the whole transcript every turn.
• Measure cost per task, not cost per token. The number that matters is what it costs to complete one real user job. A cheaper model that needs four attempts is not cheaper.
• Treat context as a product decision. What the agent remembers, and for how long, changes both the bill and the user experience. Someone should own that choice.

The deeper implication is that memory is becoming architecture. The companies getting real value from AI in 2026 are the ones that built careful pipelines for what enters the model's context, ranked retrieval, freshness checks, deduplication, and explicit rules about what to forget. This is unglamorous engineering, and it is where the margin lives.

For business leaders, the practical takeaway is blunt: any AI feature without a cost model per user is a liability waiting to hit your P&L. Ask your teams what a single completed task costs today, and what it will cost at ten times the volume. If nobody can answer, that is the finding.

Open-Source Inference: The Lever for Control and Cost

The third theme is the one that changes the strategic board. Open-source inference is the practice of running models, often openly available ones, on infrastructure you control, rather than only calling a hosted API.

Two forces are pushing this to the center of the conversation. The first is cost predictability. When you run your own inference, your cost curve looks like a capacity plan, not a meter that spins faster with every user. The second is control: data residency, customization, the ability to keep serving when a vendor changes terms, and the freedom to fine-tune on your own domain.

Just as important is what open-source inference does to the shape of the market. When capable open models are available and the tooling to serve them gets simpler, no single vendor can hold the whole stack hostage. Companies can route the easy 80% of traffic to a cheap self-hosted model and reserve premium hosted models for the genuinely hard cases. That hybrid routing pattern is quietly becoming the default architecture for serious AI teams.

It is not a free lunch. Self-hosting means owning GPUs or negotiating for them, managing utilization, handling upgrades, and staffing people who understand serving performance. For a small team, a hosted API is still the right call. The point is that the choice now exists where it did not before, and that a real choice changes your negotiating position even if you never exercise it.

How to think about the build-versus-buy decision

• Volume matters. High, steady, well-understood workloads are the best candidates for self-hosting. Spiky or experimental ones are not.
• Data sensitivity matters. If the data cannot leave your walls, open-source inference stops being an optimization and becomes a requirement.
• Differentiation matters. If the model itself is your edge, own it. If it is a commodity input to a better product, rent it.
• Keep the exit door unlocked. Build an abstraction layer so you can swap providers or models without rewriting the product. Portability is insurance.

Why These Three Themes Belong Together

The program committee's picks are not three separate topics. They are one story told in three parts.

Agents are what make AI genuinely useful, they turn a chat box into a worker. But agents create identity problems the moment they can act, and they inflate context costs the moment they remember. And the only durable way to answer both the trust question and the cost question is to own more of the stack, which is exactly what open-source inference enables.

Put differently: identity is how you make agents safe, context economics is how you make them affordable, and open inference is how you make them yours. Skip any one and the system fails, safe but unaffordable, cheap but unaccountable, or capable but captive.

What This Means for the Future of AI

Three predictions follow from this agenda.

First, AI budgets will get audited like cloud budgets. The first wave of AI spending was exploratory and loosely tracked. The next wave will be measured per task, per user, and per outcome. Teams that cannot show a cost-per-completed-job number will lose funding to teams that can.

Second, "agent governance" will become a real job title. Just as DevOps emerged when cloud infrastructure got complicated, a discipline will form around running fleets of agents with proper permissions, logging, and review. The companies hiring for it now will have a two-year head start.

Third, the model layer will commoditize faster than the application layer. As open-source inference matures, raw model quality stops being a moat. What becomes defensible is the boring stuff: your data, your workflows, your guardrails, your evaluation harness, and your cost discipline. That is good news for businesses, because it means advantage comes from execution rather than from who signed the biggest contract.

Actionable Steps to Take This Quarter

• Inventory every agent in production or pilot. For each one, write down the identity it uses, the systems it can touch, and who is accountable for its actions.
• Add a cost-per-task dashboard. Track tokens, latency, and dollars for one representative user journey. Publish it where product and finance can see it.
• Run a context diet. Take your most expensive prompt and cut its input by half using retrieval and summarization. Measure quality before and after.
• Test one open model on one workload. Pick a narrow, high-volume task. Compare quality, cost, and operational burden against your current hosted setup.
• Build a model abstraction layer. If swapping a model requires a rewrite, you do not have an AI product, you have a dependency.
• Write your agent policy now. What agents may do without approval, what requires a human, and how actions get logged. A short written policy beats a long incident review.

The Bottom Line

The most telling thing about the QCon AI New York 2026 picks is what is absent. There is no headline about a bigger model or a flashier benchmark. The conversation has moved to identity, cost, and control, the concerns of people who are actually shipping.

That is a sign of a maturing field, and a warning to anyone still treating AI as a demo exercise. The winners over the next two years will not be the teams with the most impressive prototypes. They will be the teams that can say precisely who their agents are, exactly what each task costs, and honestly whether they own the stack underneath. Those are unglamorous answers. They are also the ones that survive contact with real users, real budgets, and real auditors.