@ -0,0 +1,8 @@ |
|||
<Project> |
|||
<!-- SDK 11.0.100 RC 2 and RC 3 add a build-only dotnet-watch JS initializer to every Web SDK project, and a Debug |
|||
build of a Web SDK project fails when it references a Web SDK project that contributes one. |
|||
Remove this file once the repository targets an SDK that no longer has this regression. --> |
|||
<PropertyGroup Condition="$(NETCoreSdkVersion.StartsWith('11.0.100-rc.')) and '$(UsingMicrosoftNETSdkWeb)' == 'true' and ('$(OutputType)' == 'Library' or $(MSBuildProjectFullPath.Contains('test')))"> |
|||
<EnableHotReloadInRuntimeConfigDevFile>false</EnableHotReloadInRuntimeConfigDevFile> |
|||
</PropertyGroup> |
|||
</Project> |
|||
@ -0,0 +1,46 @@ |
|||
You know us from the ABP Framework. For some time now we have also been building something else with it, and this is the first time we write about it here. |
|||
|
|||
**Volobox** is a team workspace where AI agents work as governed team members. Since August we have been onboarding teams one at a time through demos and running our own company on it. Today it is generally available: any team can request a free demo, have its own workspace set up the same day, and use it free for 30 days. |
|||
|
|||
This post is for the ABP community: what Volobox is, how it is built, and what it means for you. |
|||
|
|||
## What Volobox is |
|||
|
|||
 |
|||
|
|||
Projects, tasks, chat, docs, meetings, files, and customer support live in one workspace, and AI agents work inside it like teammates. An agent has a handle, skills, memberships, and a manager. You assign it a task the same way you assign one to a colleague, mention it in chat, or put it on a scheduled playbook. |
|||
|
|||
For a bug, the agent writes the code and comes back with a pull request. The coding session runs in an isolated sandbox and you can watch it live: the plan, the terminal, the file diffs, what each step costs. You review the pull request in Volobox, and "request changes" hands your feedback straight back to the agent. GitHub, GitLab.com, and Azure Repos are supported. |
|||
|
|||
What makes this workable with a real team is the governance model. Every agent action is permissioned, approved, and audited: approval cards for writes, three authorization modes, standing rules with budgets, rate limits, and an audit log. An agent assigned a task acts under its own permissions, not the assigner's. |
|||
|
|||
## How it is built |
|||
|
|||
Volobox is a .NET 10 layered ABP application (will be migrated to .NET 11 very soon): the modular backend you would recognize, a React frontend, PostgreSQL, SignalR for realtime, and sandboxes that run in the cloud or on a computer the person owns. Identity, permissions, settings, features, and auditing are the ABP modules you already use. |
|||
|
|||
**Custom Apps**, the part of Volobox where a team builds internal tools by describing them to an agent, runs on the low-code engine of the ABP Framework, which our team develops. You describe the app, approve what the agent proposes, and get a live app; when you need more, you continue in JavaScript or C# without replatforming. |
|||
|
|||
Running agents against a large ABP codebase every day has taught us a lot about what agents get right and wrong in a modular .NET solution. That experience goes back into the framework as ordinary improvements, and we will talk about it openly in the Community Talks session below. |
|||
|
|||
## What it means for ABP developers |
|||
|
|||
- **Nothing changes about ABP.** Same licensing, same support, same team. Volobox is a separate product. |
|||
- **Agents on your own code.** Connect your repository, assign an issue to an agent, and review the pull request in the workspace. Start with agents in Ask mode if you prefer. It is not restricted by ABP Framework. **It works with any kind of programming language and tool**. |
|||
- **Keep your current tools.** Start with one project, keep GitHub or GitLab issues in sync, connect what you already use over MCP. |
|||
- **Extend it the way you extend ABP.** Library packs, skills, commands, MCP in both directions, Custom Apps on the low-code engine. |
|||
|
|||
## Generally available |
|||
|
|||
The way to start is a free 30-minute demo on your own use cases. Bring an open issue; we assign it to an agent and review the pull request together. After the demo we set up your own Volobox Cloud workspace the same day, with model access we manage, and you use it free for 30 days. When the trial ends you choose a plan and keep working; otherwise the workspace is closed. |
|||
|
|||
Volobox runs in Volobox Cloud, or on a private cloud or on-premise for Enterprise. Every plan has the full product; plans differ in capacity, not capability. The comparison is on the [pricing page](https://volobox.io/pricing). |
|||
|
|||
## See it live |
|||
|
|||
We are preparing an **ABP Community Talks** session on Volobox, in English: an open issue taken to a pull request live, the governance model, and how Volobox is built on ABP. The date and registration link will be announced on the [events page](https://abp.io/community/events). If you are joining [ABP Community Talks 2026.6](https://abp.io/community/events/community-talks/abp-ai-coding-agent-for-every-.net-developer-618qay6o) this Thursday, we will also take five minutes there for a first look. |
|||
|
|||
- Announcement: [Volobox is generally available](https://volobox.io/blog/volobox-is-generally-available) |
|||
- Request a free demo: [volobox.io/demo](https://volobox.io/demo) |
|||
- Product: [volobox.io](https://volobox.io) |
|||
|
|||
Thank you for building with ABP. We hope some of you will build with Volobox too. |
|||
|
After Width: | Height: | Size: 129 KiB |
|
After Width: | Height: | Size: 835 KiB |
@ -0,0 +1,463 @@ |
|||
# Keeping a Fast-Growing ABP Application Fast: What We Learned from Volobox |
|||
|
|||
At Volosoft we run our own work on [Volobox](https://volobox.io), a workspace where people and AI agents work together. Agents take assigned tasks, answer in chat when someone mentions them, draft documents and run scheduled playbooks. They follow the same permissions as everyone else, and their work goes into the same audit log. The workspace also has projects and tasks, team chat, docs, meetings, support desks and AI coding. |
|||
|
|||
[Volobox](https://volobox.io) is an ABP application with a React front end, and it moves fast: new features ship every few days. Between mid-August and early October, we added video meetings, calendar sync, booking pages and support desks with a customer portal. We also added a choice of coding agents and coding sessions on your own machines. And it got much faster: between two releases, the home page data took about **90% less time** in a warm API replay against production, and the median replay now finishes in under half a second. In local runs, a page refresh shows the home page in 0.8 seconds, about 70% faster. |
|||
|
|||
ABP is a big part of why we can build that fast. Its modules, dependency injection, units of work and conventions handle the plumbing, so we spend our time on features. In a few months [Volobox](https://volobox.io) grew to: |
|||
|
|||
- thousands of C# files and a few hundred application services, |
|||
- around a thousand services with interceptors (unit of work, auditing, authorization, ...), |
|||
- dozens of background workers, |
|||
- one process in production, with Autofac, PostgreSQL and Redis. |
|||
|
|||
At this size, some costs that are too small to notice in a typical application start to add up. We were preparing to deliver [Volobox](https://volobox.io) to customers, so we spent a few rounds on performance. Besides the home page numbers above, startup got 62% faster in container A/B runs, to about 14 seconds. |
|||
|
|||
We kept the same database and did not rewrite anything. Here is how we found the costs that had grown with [Volobox](https://volobox.io), and what we changed. |
|||
|
|||
## How we found the bottlenecks |
|||
|
|||
Timings are noisy. The same request can be fast or slow depending on what else the process is doing. So we built a few signals that tell us where to look, not only that something is slow. Most of them are small and stay in the product. |
|||
|
|||
### A runtime line every minute |
|||
|
|||
A background worker logs one line a minute with what the whole process is doing. A simplified version: |
|||
|
|||
```csharp |
|||
var stopwatch = Stopwatch.StartNew(); |
|||
var pauseBefore = GC.GetTotalPauseDuration(); |
|||
var allocatedBefore = GC.GetTotalAllocatedBytes(); |
|||
var gen2Before = GC.CollectionCount(2); |
|||
|
|||
await Task.Delay(TimeSpan.FromMinutes(1), cancellationToken); |
|||
|
|||
// Under load the delay can end late, so divide by the time that really passed. |
|||
var elapsed = stopwatch.Elapsed; |
|||
var info = GC.GetGCMemoryInfo(); |
|||
Logger.LogInformation( |
|||
"Runtime saturation: threads={Threads} pending={Pending} gcPause={GcPause:P1} " + |
|||
"alloc={AllocMb} MB gen2={Gen2} heap={HeapMb} MB", |
|||
ThreadPool.ThreadCount, |
|||
ThreadPool.PendingWorkItemCount, |
|||
(GC.GetTotalPauseDuration() - pauseBefore) / elapsed, |
|||
(GC.GetTotalAllocatedBytes() - allocatedBefore) / 1024 / 1024, |
|||
GC.CollectionCount(2) - gen2Before, |
|||
info.HeapSizeBytes / 1024 / 1024); |
|||
``` |
|||
|
|||
Ours also logs database pool waits, slow DNS lookups, heap fragmentation and the container's CPU throttling (from the cgroup `cpu.stat` file). The line does not give the answer, but it tells us which tool to pick up next: |
|||
|
|||
- A high `gcPause` with a low `pending` count points to allocations. More threads will not help, so the next step is an allocation trace. |
|||
- Database pool waiters with a low `pending` count point to the connection pool, not the thread pool. |
|||
- To tell a leak from churn, compare live objects after full GCs under a similar load. The logged heap size comes from the latest GC and includes fragmentation, so it is only a first hint. If live objects keep growing, follow the references in a heap dump. If they stay flat while `alloc` is high, look for what allocates. |
|||
|
|||
One caveat for `alloc`: on our .NET 10 host with Server GC, the allocation counter could stay flat for many samples and then catch up at once. We check gen 0 GC counts and allocation traces before reading much into a single minute. |
|||
|
|||
### The cost of each request on its log line |
|||
|
|||
The second signal puts three numbers on every request summary line: the GC pause time while the request ran, the thread pool queue length when it started, and how many resolve requests the container served for it. With Serilog's request logging, it is a small middleware that runs inside `UseSerilogRequestLogging`: |
|||
|
|||
```csharp |
|||
public async Task InvokeAsync(HttpContext httpContext) |
|||
{ |
|||
var pendingAtStart = ThreadPool.PendingWorkItemCount; |
|||
var pauseAtStart = GC.GetTotalPauseDuration(); |
|||
|
|||
// Our own counter, described in the next section. It returns null when counting is off. |
|||
using var tally = _resolveCounter.Start(httpContext.RequestServices); |
|||
try |
|||
{ |
|||
await _next(httpContext); |
|||
} |
|||
finally |
|||
{ |
|||
_diagnosticContext.Set("GcPauseMs", (long)(GC.GetTotalPauseDuration() - pauseAtStart).TotalMilliseconds); |
|||
_diagnosticContext.Set("ThreadPoolPending", pendingAtStart); |
|||
if (tally != null) |
|||
{ |
|||
_diagnosticContext.Set("DiResolves", tally.Count); |
|||
} |
|||
} |
|||
} |
|||
``` |
|||
|
|||
These fields tell us what to check for a slow request. `GcPauseMs` is process-wide: it is the GC pause time that overlapped the request. When it is close to the request's duration, an allocation trace is the next thing to check. A high `ThreadPoolPending` shows that the process had queued work when the request started. A common read in [Volobox](https://volobox.io) makes several thousand resolve requests, so hundreds of thousands means a constructor graph has grown and is worth a look. |
|||
|
|||
Skip SignalR and other long-lived connections here, or one request gets the cost of hours of hub calls. |
|||
|
|||
### Counting resolve requests |
|||
|
|||
The resolve count comes from Autofac's own events. For one service in one scope, it takes a few lines: |
|||
|
|||
```csharp |
|||
var count = 0; |
|||
using var scope = lifetimeScope.BeginLifetimeScope(); |
|||
scope.ResolveOperationBeginning += (_, operation) => |
|||
{ |
|||
operation.ResolveOperation.ResolveRequestBeginning += (_, _) => count++; |
|||
}; |
|||
|
|||
scope.Resolve<IProjectTaskAppService>(); |
|||
// count is now the number of resolve requests for this one resolve |
|||
``` |
|||
|
|||
The counter in the host does the same per request and per background worker run. It also follows the scopes that a request creates through `IServiceScopeFactory`, because those start from the root container, not under the request's scope. A worker run that makes 20,000 or more resolve requests logs one line with its name, duration and item count. We turn the counter on with a configuration switch, because three event subscriptions per scope are not free under load. |
|||
|
|||
### Ranking every component by graph size |
|||
|
|||
To find which service to look at first, we resolved every transient and scoped application component once, each in a fresh child scope, and sorted them by resolve requests. The same event also tells us who asked for each component, which gives the edges of the graph: |
|||
|
|||
```csharp |
|||
static Type Owner(Type type) => |
|||
type.Namespace == "Castle.Proxies" && type.BaseType != null ? type.BaseType : type; |
|||
|
|||
var rows = new List<(long Count, Type Type)>(); |
|||
var edges = new Dictionary<string, long>(); |
|||
var failures = new List<(Type Type, string Error)>(); |
|||
|
|||
var registrations = root.ComponentRegistry.Registrations |
|||
.Where(r => Owner(r.Activator.LimitType).Namespace?.StartsWith("MyCompany.MyApp") == true |
|||
&& !r.Activator.LimitType.IsGenericTypeDefinition |
|||
&& (r.Sharing == InstanceSharing.None || r.Lifetime is CurrentScopeLifetime)) |
|||
.DistinctBy(r => r.Activator.LimitType) |
|||
.ToArray(); |
|||
|
|||
foreach (var registration in registrations) |
|||
{ |
|||
using var scope = root.BeginLifetimeScope(); |
|||
long count = 0; |
|||
var componentEdges = new Dictionary<string, long>(); |
|||
scope.ResolveOperationBeginning += (_, operation) => |
|||
operation.ResolveOperation.ResolveRequestBeginning += (_, request) => |
|||
{ |
|||
count++; |
|||
// While this event runs, the active request is the one that asked for this component. |
|||
var parent = operation.ResolveOperation.ActiveRequestContext; |
|||
if (parent != null) |
|||
{ |
|||
var edge = $"{Owner(parent.Registration.Activator.LimitType).FullName} -> " + |
|||
$"{Owner(request.RequestContext.Registration.Activator.LimitType).FullName}"; |
|||
componentEdges[edge] = componentEdges.GetValueOrDefault(edge) + 1; |
|||
} |
|||
}; |
|||
|
|||
try |
|||
{ |
|||
// Resolve this registration, not whichever one is the default for its service, |
|||
// through the service pipeline so sharing and decorators still apply. |
|||
var service = registration.Services.First(); |
|||
var serviceRegistration = scope.ComponentRegistry.ServiceRegistrationsFor(service) |
|||
.Single(candidate => candidate.Registration.Id == registration.Id); |
|||
scope.ResolveComponent(new ResolveRequest(service, serviceRegistration, Array.Empty<Parameter>())); |
|||
|
|||
rows.Add((count, Owner(registration.Activator.LimitType))); |
|||
foreach (var edge in componentEdges) |
|||
{ |
|||
edges[edge.Key] = edges.GetValueOrDefault(edge.Key) + edge.Value; |
|||
} |
|||
} |
|||
catch (DependencyResolutionException ex) |
|||
{ |
|||
// Some components need parameters or runtime state. |
|||
failures.Add((Owner(registration.Activator.LimitType), ex.Message)); |
|||
} |
|||
} |
|||
|
|||
var rankedRows = rows.OrderByDescending(row => row.Count).ToArray(); |
|||
var rankedEdges = edges.OrderByDescending(edge => edge.Value).ToArray(); |
|||
``` |
|||
|
|||
Start with the services at the top of the ranking. The failures tell you which components it could not cover. Then check the edge list for the dependencies that make those graphs large. For a single service, resolve each constructor parameter type on its own to see how much it adds, and check which methods really use it before you make it lazy. |
|||
|
|||
### Replaying the real page |
|||
|
|||
To measure the home page, we took the API calls it makes (14 calls in seven groups) from a browser HAR file and replayed them with a small script against production: first all together, the way the browser sends them, then one by one. The script reads the application version first, so every result is tied to a release, and runs ten rounds for a median. Before timing, it calls every API once to warm the connections and the server, so the numbers are warm API replays. They do not include HTML, JavaScript or rendering. We ran it before and after the release with the fix. |
|||
|
|||
### Allocation traces and heap dumps |
|||
|
|||
When the signals point to allocations or memory, the .NET diagnostic tools show the source: |
|||
|
|||
```bash |
|||
# What the runtime is doing, live |
|||
dotnet-counters monitor -p <pid> --counters System.Runtime |
|||
|
|||
# Which call stacks allocate |
|||
dotnet-trace collect -p <pid> --profile gc-verbose --duration 00:00:05:00 |
|||
|
|||
# What is alive: take one dump before the load and one during it, then compare |
|||
dotnet-dump collect -p <pid> --type Heap -o during.dmp |
|||
dotnet-dump analyze during.dmp -c "dumpheap -stat -live" -c exit > during.txt |
|||
``` |
|||
|
|||
Compare two `dumpheap -stat -live` outputs to see which types grow under load. |
|||
|
|||
### Controlled A/B runs |
|||
|
|||
For changes that are hard to see in production, we ran the old and the new image one after the other in containers with the production CPU and memory limits (`docker run --cpus 3.8 --memory 8g`), the same seed data and the same simulated users. LLM calls were stubbed so the load stayed the same. For each run we recorded the time until the health check passed, the container's CPU time from the cgroup files, and a heap dump during the load. |
|||
|
|||
## The six bottlenecks |
|||
|
|||
We found six bottlenecks: |
|||
|
|||
| # | Where | What we saw | What we changed | Result | |
|||
|---|---|---|---|---| |
|||
| 1 | Constructor graphs | One application service resolve triggered hundreds of thousands of resolve requests | `Lazy<T>`, keyed services, a budget test | Home page data −90% (production replay), all APIs p50 −30% (production, whole round) | |
|||
| 2 | After-commit work | One long operation held thousands of live scopes | Carry values, open a scope when the work runs | Live scopes −99%, heap after full GC −22% (lab, whole round) | |
|||
| 3 | Transactions | A page-long connection and a minute-long request held a transaction the whole time | A rule for hub routes, a separate non-transactional unit of work | Preview start peak CPU −87% (local, whole round) | |
|||
| 4 | Background workers | Workers built all their services before they knew there was work | Check first, build only when needed | Resolve requests per run −99% (local) | |
|||
| 5 | Startup | Cold connections and controllers, around a thousand proxy classes in one dynamic module | Warm up before ready, 16 proxy modules | Startup −62% (lab, whole round), first calls −97% (p50, local, whole round) | |
|||
| 6 | Front end | Six startup requests in a row and a large static JavaScript bundle | Inline runtime config, static outline, token reuse, on-demand loading, IndexedDB | Refresh −70% (local) | |
|||
|
|||
"Production replay" is the home page replay above. "Local" means local tests and page replays. "Lab" means the container A/B runs above. "Whole round" means the number compares two builds that differ in more than this one change. |
|||
|
|||
## 1. Constructor graphs |
|||
|
|||
### The problem |
|||
|
|||
Every HTTP request builds the constructor graph of the application service it calls, before the first line of the method runs. A transient service that is reached along ten different paths is built ten times. In a small application this is nothing. With hundreds of services that depend on each other, the cost multiplies. |
|||
|
|||
When features are added quickly, the graph grows in a natural way: |
|||
|
|||
- an application service injects another application service for one method, |
|||
- a registry takes `IEnumerable<IProvider>` and builds every provider in its constructor, |
|||
- a shared service (push notifications, code host providers, an agent tool catalog) is injected into many classes that use it on one path, |
|||
- something that runs for every `DbContext` or every save brings a bigger graph than it needs. |
|||
|
|||
Each of these is a reasonable choice on its own. Together, one `IProjectRequestAppService` resolve had grown to hundreds of thousands of resolve requests, and resolving every [Volobox](https://volobox.io) component once came to tens of millions. |
|||
|
|||
We found it from the runtime line: the GC pause stayed high while only a few requests were running. Allocation traces put most allocations under Autofac activation, and the component ranking gave the list of services and the edges that made them big. |
|||
|
|||
### Resolve dependencies only when they are needed |
|||
|
|||
A dependency that only some methods use becomes `Lazy<T>`. Autofac supports it out of the box, and ABP's `LazyServiceProvider` does the same for base class properties. The example uses small, illustrative types: |
|||
|
|||
```csharp |
|||
public class ReportAppService : ApplicationService |
|||
{ |
|||
private readonly IReportRepository _reportRepository; |
|||
private readonly Lazy<IReportExporter> _exporter; |
|||
|
|||
public ReportAppService( |
|||
IReportRepository reportRepository, |
|||
Lazy<IReportExporter> exporter) |
|||
{ |
|||
_reportRepository = reportRepository; |
|||
_exporter = exporter; |
|||
} |
|||
|
|||
public virtual async Task<byte[]> ExportAsync(Guid id) |
|||
{ |
|||
// Only this method pays for the exporter's graph. |
|||
var report = await _reportRepository.GetAsync(id); |
|||
return await _exporter.Value.ExportAsync(report); |
|||
} |
|||
} |
|||
``` |
|||
|
|||
`Lazy<T>` only defers the cost. When one application service calls another just to reuse some logic, the better fix is to move that logic into a domain service, as ABP's [application service best practices](https://abp.io/docs/latest/framework/architecture/best-practices/application-services) recommend. |
|||
|
|||
A registry takes `Lazy<IEnumerable<T>>` and builds its index on first use, or resolves one implementation by key with a keyed service. Enumerating all three code host providers (GitHub, GitLab, Azure DevOps) cost about 2,000 resolve requests per scope. Resolving only the one we need costs a few. |
|||
|
|||
Two more costs came with `DbContext`, and we took a different path for each. In [Volobox](https://volobox.io)'s Identity Pro setup, the compiled-query cache key now comes from a small provider that reads the same values directly, which saved about 570 resolve requests for every `DbContext`. The first save on a `DbContext` built the audit store, even outside an audit scope. Now it is resolved only when a log is written, which saved about 120 resolve requests per `DbContext`. |
|||
|
|||
Resolving every [Volobox](https://volobox.io) component once now takes about 95% fewer resolve requests. In the production replay, the home page data took about 90% less time (median of 10 rounds), the median now finishes in under half a second, and each of its seven groups of calls dropped by about 90%. |
|||
|
|||
The production logs showed the same trend across all API requests. We compared the daytime hours before and after a later release in this round. In those hours, the median (p50) response time dropped by 30% to about 38 ms, and the 90th percentile (p90) dropped by 26%, while the request rate grew by 57%. Resolve requests per request were cut in half, and CPU per request dropped by about 30%. That release also carried other changes, so this is a whole-round number. |
|||
|
|||
To keep it that way, we added a test that resolves the services we call most and fails when a graph grows past its budget: |
|||
|
|||
```csharp |
|||
[Theory] |
|||
[InlineData(typeof(IProjectTaskAppService), 5_000)] |
|||
[InlineData(typeof(IConversationAppService), 10_000)] |
|||
[InlineData(typeof(IPullRequestAppService), 6_000)] |
|||
public void Resolving_a_busy_service_stays_within_its_graph_budget(Type serviceType, int budget) |
|||
{ |
|||
CountResolveRequests(serviceType).ShouldBeLessThanOrEqualTo(budget); |
|||
} |
|||
``` |
|||
|
|||
The budgets are well above today's graphs. If a test fails, we look for a new eager dependency that pulls in a large graph, and we catch the cost before it reaches production. |
|||
|
|||
## 2. After-commit work |
|||
|
|||
### The problem |
|||
|
|||
[Volobox](https://volobox.io) leaves some work for after the commit, such as push notifications. A local event handler in ABP runs in its own short scope, which ends when the handler returns, and the unit of work commits later. So an after-commit callback must not rely on services from the handler's scope. This is easy to miss with `Lazy<T>`: on first access, it resolves its value from the scope that created the object holding it: |
|||
|
|||
```csharp |
|||
public async Task HandleEventAsync(TaskAssignedEvent eventData) |
|||
{ |
|||
_unitOfWorkManager.Current.OnCompleted(async () => |
|||
{ |
|||
// Runs after the commit. This handler's scope may be disposed by now. |
|||
await _pushNotifier.Value.SendAsync(eventData.AssigneeId); |
|||
}); |
|||
} |
|||
``` |
|||
|
|||
Our first answer was to keep each handler's scope alive until the unit of work ended. Each kept scope holds its own objects, and in a long operation that publishes many events, one request ended up holding thousands of live scopes. We found it by comparing heap dumps taken before and during a load: the number of `LifetimeScope` objects grew with the number of events the operation published. |
|||
|
|||
### Carry values and open a fresh scope |
|||
|
|||
Carry values, not services, and open a fresh scope when the work runs. The event and notifier types here are illustrative: |
|||
|
|||
```csharp |
|||
public class AfterCommitScope : ISingletonDependency |
|||
{ |
|||
private readonly IServiceScopeFactory _scopeFactory; |
|||
|
|||
public AfterCommitScope(IServiceScopeFactory scopeFactory) |
|||
{ |
|||
_scopeFactory = scopeFactory; |
|||
} |
|||
|
|||
public async Task RunAsync<TState>(TState state, Func<IServiceProvider, TState, Task> work) |
|||
{ |
|||
await using var scope = _scopeFactory.CreateAsyncScope(); |
|||
await work(scope.ServiceProvider, state); |
|||
} |
|||
} |
|||
|
|||
// In the handler: copy the values first, so the callback holds neither the handler nor the event. |
|||
var assigneeId = eventData.AssigneeId; |
|||
var afterCommitScope = _afterCommitScope; |
|||
|
|||
_unitOfWorkManager.Current.OnCompleted(() => afterCommitScope.RunAsync( |
|||
assigneeId, |
|||
static (services, id) => services |
|||
.GetRequiredService<PushNotifier>() |
|||
.SendAsync(id))); |
|||
``` |
|||
|
|||
The new scope does not change the ambient unit of work or tenant. Work that writes to the database starts its own unit of work with `requiresNew: true`. If the handler switched tenants, carry that tenant in the state too. |
|||
|
|||
In the lab A/B run of this round, a heap dump taken while previews were starting held 99% fewer live `LifetimeScope` objects. While all three previews were still running, the heap after a full GC peaked 22% lower. |
|||
|
|||
## 3. Transactions |
|||
|
|||
### The problem |
|||
|
|||
Most [Volobox](https://volobox.io) requests are short API calls. Two kinds are not. |
|||
|
|||
**SignalR hub connections.** [Volobox](https://volobox.io) keeps one SignalR connection per browser tab. In our HTTP/2 setup, a hub connection arrives as a `CONNECT` request that lasts as long as the page, and a transaction opened for it stays open just as long. We found one by listing open transactions during a browser test: |
|||
|
|||
```sql |
|||
SELECT pid, state, now() - xact_start AS age, left(query, 80) |
|||
FROM pg_stat_activity |
|||
WHERE state = 'idle in transaction' |
|||
ORDER BY age DESC; |
|||
``` |
|||
|
|||
**Long-running requests.** Starting a preview environment for a coding session can take minutes, and most of that time is spent waiting for other systems. The request held its transaction the whole time, and a few steps did work that grew with the number of steps (a large setup log write, large file buffers). A local run kept more than one CPU core busy and ran dozens of gen 2 GCs a minute. Its request line showed a long request with a high resolve count, and a `gc-verbose` trace of the same run showed where it allocated. |
|||
|
|||
### A transaction rule for each kind of request |
|||
|
|||
We gave the hub routes an explicit non-transactional rule, separate from ordinary API requests. ABP lets an application replace its transaction behavior provider for this: |
|||
|
|||
```csharp |
|||
[Dependency(ReplaceServices = true)] |
|||
[ExposeServices(typeof(IUnitOfWorkTransactionBehaviourProvider), typeof(AspNetCoreUnitOfWorkTransactionBehaviourProvider))] |
|||
public class HubUnitOfWorkTransactionBehaviourProvider : AspNetCoreUnitOfWorkTransactionBehaviourProvider |
|||
{ |
|||
private readonly IHttpContextAccessor _httpContextAccessor; |
|||
|
|||
public HubUnitOfWorkTransactionBehaviourProvider( |
|||
IHttpContextAccessor httpContextAccessor, |
|||
IOptions<AspNetCoreUnitOfWorkTransactionBehaviourProviderOptions> options) |
|||
: base(httpContextAccessor, options) |
|||
{ |
|||
_httpContextAccessor = httpContextAccessor; |
|||
} |
|||
|
|||
public override bool? IsTransactional => |
|||
_httpContextAccessor.HttpContext?.Request.Path.StartsWithSegments("/signalr-hubs") == true |
|||
? false |
|||
: base.IsTransactional; |
|||
} |
|||
``` |
|||
|
|||
For the preview start, the application service method turns off its automatic unit of work and opens a separate, non-transactional one for the preview flow. A simplified version: |
|||
|
|||
```csharp |
|||
[UnitOfWork(IsDisabled = true)] |
|||
public virtual async Task<PreviewDto> StartPreviewAsync(Guid sessionId) |
|||
{ |
|||
using var uow = UnitOfWorkManager.Begin(requiresNew: true, isTransactional: false); |
|||
var result = await StartPreviewCoreAsync(sessionId); |
|||
await uow.CompleteAsync(); |
|||
return result; |
|||
} |
|||
``` |
|||
|
|||
The attribute alone only covers this method. The explicit `requiresNew` unit of work is what keeps the long flow out of the request's unit of work. Together with smaller setup log writes and file buffers, the peak CPU of the same local preview start fell by about 87% across that round, with almost no gen 2 GCs. |
|||
|
|||
## 4. Background workers |
|||
|
|||
### The problem |
|||
|
|||
Background workers are easy to forget, because nobody waits for them. In a single process they share the CPU with requests. |
|||
|
|||
Our pull request status worker runs every 15 minutes. It read the newest 200 merged pull requests, loaded their links one by one, and built its notifier and coordinator before it checked whether any task needed to change. Our queue workers sleep until something is written for them, but built their dependencies before they waited. |
|||
|
|||
We found these by searching the worker log lines for runs with high resolve counts. |
|||
|
|||
### Check for work before building anything |
|||
|
|||
We changed the workers to check for work before building their services. The pull request status worker now asks the database one question first ("which merged pull requests still have open linked tasks?"), and builds the heavy services only when the answer is not empty. In a local run with a small test set, that cut its resolve requests by more than 99%. Our issue sync, with 10 issues, made 89% fewer. |
|||
|
|||
The queue workers now wait for their signal first and build their dependencies after it. Across this round of background-work and dependency changes, CPU on an idle local host dropped by 40%. |
|||
|
|||
## 5. Startup |
|||
|
|||
### The problem |
|||
|
|||
A fresh process has cold database connections and has not built its controllers yet, so the first users after a deploy pay for both. Right after a deploy, the runtime line showed many new database connections in the first minute, and the first call to each home page API took much longer than the second. |
|||
|
|||
Startup itself was long too. An EventPipe CPU sampling trace of a starting host showed proxy type generation near the top. Castle DynamicProxy keeps generated classes in a dynamic module, and generating a new class gets slower as that module grows. Generating proxies in batches of 50 showed each batch getting slower than the one before, and [Volobox](https://volobox.io) has around a thousand proxy classes. |
|||
|
|||
### Warm up before ready, and spread the proxies |
|||
|
|||
- **Warm up before reporting ready.** Before the host tells the orchestrator it is ready, it opens a batch of database connections, runs the first queries and builds the controllers the home page needs. Locally, across that round of changes, the first calls to 30 home page APIs got about 97% faster (p50). The host reports ready a bit later, and these first-request costs move into startup. |
|||
- **Spread the dynamic proxies.** We spread the proxies over 16 dynamic modules. In the lab, this change alone made the host ready 57% sooner. With the rest of that round, startup got 62% faster and used 57% less CPU, in containers with the same limits. |
|||
|
|||
## 6. The front end |
|||
|
|||
### The problem |
|||
|
|||
A HAR file of a page refresh showed six configuration and sign-in requests running one after another before anything appeared, one of them only to read the runtime configuration. A bundle report from the Vite build showed the first page loading several megabytes of statically imported JavaScript (gzip), and the import chain behind each large module. |
|||
|
|||
### Draw the page first, and fetch less |
|||
|
|||
- The host writes the runtime configuration into the HTML, so the page does not fetch it. |
|||
- The page draws the outline of the workbench (top bar, sidebars, home cards) in plain HTML before the React app starts. |
|||
- A refresh in the same signed-in tab reuses its valid access token, and the OIDC discovery document is cached, so the sign-in round trips are gone from a normal refresh. |
|||
- Pages, editors and language files load on demand. This step cut statically imported JavaScript by about 60% (gzip). The active language loads first, and the English fallback loads in the background. |
|||
- Home page data is kept in IndexedDB for each user, cleared on sign-out, and shown at once, then refreshed from the server. |
|||
|
|||
A Playwright script with a simulated network delay timed the first paint, the greeting and the first task card for each change. With a 300 ms simulated delay and gzip, a normal refresh now shows the home page in 0.8 seconds, about 70% faster. |
|||
|
|||
## A short checklist |
|||
|
|||
- Log a runtime line every minute, and put GC pause, thread pool queue and resolve count on every request line. |
|||
- Count Autofac resolve requests per request and per worker run. Rank components by graph size, and put a budget test on your most-used services. |
|||
- Inject only what a class uses. Make a dependency that only some methods use `Lazy<T>`. |
|||
- Do not inject `IEnumerable<T>` when a call needs only one implementation. Use keyed services, or `Lazy<IEnumerable<T>>` when only some calls need them all. |
|||
- Work left for after the commit carries values and opens its own scope. |
|||
- Check the unit of work and transaction behavior for long-lived connections and requests that take minutes. |
|||
- Make a background worker check whether there is work before it builds anything. |
|||
- Warm up database connections and the controllers the home page needs before reporting ready. |
|||
|
|||
We used production logs to find the problems. The home page numbers come from replaying the home page's API calls against production before and after a release, and the all-API numbers come from production logs before and after a later release. The other numbers come from local and lab A/B runs, so they show the direction and the size of each change, not exact production values. |
|||
|
|||
## About [Volobox](https://volobox.io) |
|||
|
|||
In [Volobox](https://volobox.io), a team plans projects on boards and milestones and assigns tasks to people or agents. People chat, edit docs and sheets together, share files, hold meetings and sync their calendars. Support desks come with a portal where customers follow their tickets. |
|||
|
|||
For coding work, an agent takes a task to a pull request while you watch the session live. Sessions run in isolated sandboxes or on your own machines. You can pick OpenCode, Cursor or Codex, or use Claude Code with your own subscription on your own machine. |
|||
|
|||
Agents use skills, library packs, MCP and custom apps, and run in scheduled and triggered workflows. Sensitive actions wait on approval cards, budgets and rate limits keep usage in check, and the audit log can be exported. |
|||
|
|||
[Volobox](https://volobox.io) Cloud is the default. Business plans can run on dedicated infrastructure, and Enterprise can run on a private cloud or on-premise, with model endpoints inside your own network. |
|||
|
|||
[Volobox](https://volobox.io) is now generally available. Any team can request a demo at [volobox.io](https://volobox.io), get a workspace the same day and use it free for 30 days. |
|||
|
After Width: | Height: | Size: 409 KiB |
|
After Width: | Height: | Size: 2.0 MiB |
@ -0,0 +1,885 @@ |
|||
# A Speaker’s Perspective: WeAreDevelopers World Congress North America 2026 (Lots Of AI) |
|||
|
|||
 |
|||
|
|||
I’ve been to quite a few developer conferences over the years but this one was a little different: **WeAreDevelopers World Congress had arrived in North America for the first time.** I traveled from Istanbul to San Francisco which took 14 hours of flying. It was exhausting but it worth. Conference was 2 days plus 1 day pre-conf. The dates are September 23–25, 2026. Host venue was San Jose McEnery Convention Center. |
|||
|
|||
The location was San José, in the heart of Silicon Valley and the scale was impressive. As I learnt the first day 9.000 developers registered and took their badges. AI builders, architects and technology leaders came together for three days of talks, workshops, networking and probably more technical conversations than anyone could keep track of. |
|||
|
|||
I was there as one of the speakers, so here are some impressions from the conference, this time from both sides of the stage 😊 |
|||
|
|||
 |
|||
|
|||
## San José, Heart of Silicon Valley |
|||
|
|||
One thing WeAreDevelopers does very well is scale. This isn’t the kind of conference where you walk into a single hall, watch ten talks, drink a few coffees and go home. Almost **10.000 attendees** came to the conf. More than **600 speakers**... **8 stages** were running in parallel alongside workshops, expo areas, networking spaces and even an outdoor stage and lounge. |
|||
And, of course, in 2026, you can probably guess the main topic: |
|||
|
|||
> **AI... Lots of AI 🙂** |
|||
|
|||
As I see, the conversations are going beyond “**look what an LLM can do**.” now. We're not surprising anymore about LLMs capabilities. |
|||
The next important questions are: |
|||
|
|||
* **How do we actually put AI into production software?** |
|||
* **How much does it cost?** |
|||
* **Is it secure?** |
|||
* **Who's responsible for the AI made results?** |
|||
* **How much effort do humans and AI expend?** |
|||
* **When will human take part if AI is doing everything?** |
|||
* **While indeterministic AI agents are writing code, how can we make more deterministic apps?** |
|||
* **Are sandboxes getting more more important?** |
|||
|
|||
 |
|||
|
|||
> *We've reached a point where none of us truly understands the internals of our own software anymore!* |
|||
|
|||
Sessions covered AI agents, AI-generated software, security for autonomous systems, testing non-deterministic behavior, developer infrastructure, data and software architecture. |
|||
|
|||
That shift feels important. The industry is no longer only experimenting with AI. Developers are trying to figure out how to make it: |
|||
|
|||
* **reliable** |
|||
* **secure** |
|||
* **maintainable** |
|||
* **really useful** |
|||
|
|||
## My Talk: Chat with Your Data |
|||
|
|||
My session was on Stage 6 on Friday 09:40. It was the first time the audience listened to me via headphones while I was speaking on stage. It was a somewhat interesting experience. :) And I made this talk before in different countries but the USA audience was very interested in my topic. They asked many questions after the session. The conversations continued even after the talk and I made some new friends there. |
|||
|
|||
 |
|||
|
|||
### Being a speaker creates a funny problem at conferences |
|||
|
|||
Before your session, a small part of your brain is always thinking about your slides, your demo and all the things that could theoretically go wrong. After the talk, suddenly the conference becomes much more relaxing. 🙂 |
|||
|
|||
And there was a lot to choose from. |
|||
|
|||
The speaker lineup included people such as Thomas Dohmke (**former GitHub CEO**), Mark Cavage (President of **Docker**), Erran Berger (CTO of **LinkedIn**), Amjad Masad (**Replit** CEO), Kelsey Hightower (**Google** Distinguished Engineer), Justin Boitano (VP of **NVIDIA**), Prashanth Chandrasekar (CEO **StackOverflow**), Eric Simons (Founder **Bolt.New**), Neel Sundaresan (General Manager AI Products **IBM**). |
|||
|
|||
 |
|||
|
|||
## The Best Part Is Still the People |
|||
|
|||
Technology conferences are supposedly about technology. |
|||
But after attending enough of them, I think the real value is often somewhere **between the sessions**. |
|||
You meet somebody after your talk. |
|||
A five-minute conversation becomes thirty minutes. |
|||
Someone tells you how they solved a problem completely differently. |
|||
Someone has been using a project you’ve worked on for years. |
|||
Or you finally meet someone you’ve known online for a long time. |
|||
With more than 10,000 people in the same place, there were plenty of opportunities for those accidental conversations. |
|||
And those are usually the moments I remember much longer than individual slides or keynotes. |
|||
|
|||
 |
|||
|
|||
## WHAT I LEARNT FROM THE TALKS |
|||
|
|||
[Jeff An](https://www.linkedin.com/in/jeff-an/) Co-founder of **Momentic.ai** → *How to Trust Code You Didn't Write*: |
|||
|
|||
> A model reviewing its own work tends to overlook the same mistakes. |
|||
> says benchmarks showed that a leading coding agent detected only 15% of the bugs it had introduced. |
|||
> So, we should avoid assigning the same agent to both write and review the code. |
|||
|
|||
[Julia Furst Morgado](https://www.linkedin.com/in/juliafmorgado/) from **Dash0** → *Your Agents Need Observability Before They Need Better Models*: |
|||
|
|||
> Your Agents Need Observability Before They Need Better Models |
|||
|
|||
[Himraj Singh](https://www.linkedin.com/in/himraj-singh-5048a266/) from **PayPal** → *Who Tests the AI?*: |
|||
|
|||
> The same inputs can now produce different outputs, making traditional testing necessary but far from sufficient. |
|||
|
|||
**Milestones of the Software Development** |
|||
|
|||
Procedural Programming → Object-Oriented Programming → Frameworks & Design Patterns → Microservices → Cloud-Native & Serverless → Agentic Software Engineering |
|||
|
|||
|
|||
|
|||
## Manufacturing Trust: Speed and Safety in the Age of Agents 🧑 Mark Cavage, President of Docker |
|||
|
|||
 |
|||
|
|||
AI agents can dramatically accelerate software development but they need deterministic security boundaries, explicit permissions and reproducible environments to operate safely at scale. |
|||
|
|||
 |
|||
|
|||
#### Takeaways |
|||
|
|||
- Sandboxing should be the default. Docker advocates microVM-based isolation so agents can operate freely inside their environments without gaining access to sensitive host systems. |
|||
- Permissions must be deterministic. Remove dangerous capabilities rather than repeatedly asking the model to behave responsibly. |
|||
- Successful task completion isn't enough. Agents must achieve their goals while staying within their intended authorization boundaries. |
|||
- Agent teams need engineering processes. Multiple collaborating agents require clearly defined roles, responsibilities, handoffs, reviews and approval gates. |
|||
- Portability and reproducibility are essential. Agent environments should work consistently across developers' laptops, teams and cloud infrastructure. |
|||
|
|||
**The 4 Requirements of an AI Agent Factory** |
|||
|
|||
 |
|||
|
|||
The following images are retrieved from https://www.docker.com/blog/coding-agent-horror-stories-the-29-million-secret-problem/. And finally the secrets are being encoded and the malware commits it to your public GitHub repo. 2349 secrets leaked. Stolen GitHub tokens made 5.500 private repos as public |
|||
|
|||
 |
|||
|
|||
**Docker's Products:** |
|||
|
|||
- **Docker SBX**: Free local microVM-based sandboxing for autonomous agents. https://www.docker.com/products/docker-sandboxes/ |
|||
- **Docker Sandbox Kits**: Reproducible specifications for agent environments, models, MCP tools, networks and permissions. https://www.docker.com/blog/docker-sandbox-kit-spec/ |
|||
- **Docker Cloud Sandboxes**: Cloud-hosted sandboxes using the same configuration and security approach as local environments. https://agentic-platform.docker.com/ |
|||
|
|||
**Actionable Insights** |
|||
|
|||
1. **Audit your current AI agent permissions:** Identify which agents can access repositories, production systems, customer data, credentials and external APIs. Eliminate unnecessary access. |
|||
|
|||
2. **Introduce sandboxing for coding agents:** Test isolated environments for Claude Code, Codex or other coding agents. **Avoid mounting** sensitive host resources into agent environments. |
|||
|
|||
3. **Design a structured multi-agent development workflow:** Define separate responsibilities for planning, implementation, testing, security review and final human approval. |
|||
|
|||
4. **Standardize environments across the team:** Store agent configurations, policies, tools and dependencies in version-controlled files to make workflows reproducible. |
|||
|
|||
5. **Measure trust alongside productivity:** Track not only completed tasks and development speed but also permission violations, human interventions, security incidents, token costs and escaped defects. |
|||
|
|||
6. **Capture organizational knowledge through agents:** Experiment with turning successful development workflows into reusable skills, while requiring approval before sharing sensitive organizational knowledge. |
|||
|
|||
For example, in the following example, even if the Builder Agent installs an infected NPM package, the malicious software cannot read emails and CRM records. Naturally secure! In software development this approach is called "**Principle of Least Privilege**". |
|||
|
|||
 |
|||
|
|||
 |
|||
|
|||
**Nvidia Unveils AI Agent Safety Platform With Hardware-Based Watchdog** |
|||
|
|||
Nvidia introduces 2 solutions: |
|||
|
|||
1. **OpenShell**: An open-source software. Isolates AI agents and controls their permissions and API access. https://github.com/NVIDIA/OpenShell |
|||
2. **Sentry**: Hardware-backed security software. Runs on NVIDIA BlueField-4 DPU to provide independent security monitoring and enforcement. |
|||
|
|||
--- |
|||
|
|||
|
|||
|
|||
## AI Decision Observability: Enabling Transparency and Trust in Intelligent Systems |
|||
|
|||
🧑**Speakers:** Amjad Shaikh (VP Platform ServiceNow) |
|||
|
|||
 |
|||
|
|||
### Key takeaways |
|||
|
|||
- AI decisions require different levels of control. Automatically **routing a support ticket** is fundamentally different from **rejecting a loan application**. |
|||
|
|||
> Autonomy should depend on risk, impact and reversibility. |
|||
- Traditional logs are insufficient. Knowing what an AI system did is not the same as understanding **why it made a particular decision**. |
|||
- Organizations must know which **information**, **model version**, **configuration** and **policies** made an AI decision. |
|||
- AI performance must be measured against business outcomes. A technically correct prediction can still produce a poor business result. So what should we measure in terms of business outcome? |
|||
|
|||
| Metric | Business outcome | |
|||
|---------------------|-----------------------------| |
|||
| Prediction accuracy | Revenue uplift | |
|||
| Tasks completed | Net time saved | |
|||
| Code generated | Maintenance cost | |
|||
| Response speed | Customer satisfaction | |
|||
| Automation rate | Cost per successful outcome | |
|||
|
|||
- **As the world changes, AI models degrade**. Continuous monitoring for data and concept drift is necessary after deployment. |
|||
- Accountability remains with the organization. Delegating a decision to AI does not transfer legal or operational responsibility to the model. |
|||
|
|||
 |
|||
|
|||
### AI Decisions Factors |
|||
|
|||
When should we use human in the loop? When should we allow AI agent to perform? |
|||
|
|||
 |
|||
|
|||
### Three Layers of AI Decision Observability |
|||
|
|||
 |
|||
|
|||
1. **Capture**: Record decisions, inputs, data lineage, model versions, policies and configurations at decision time. |
|||
|
|||
2. **Interpret**: Analyze feature influence, decision robustness, model drift and potential causal relationships. |
|||
|
|||
3. **Govern**: Preserve tamper-evident evidence, enforce accountability and support audits and investigations. |
|||
|
|||
**Practical Example: An AI Sales Agent recommends a 20% discount to a potential customer.** |
|||
|
|||
1. **Capture: What happened?** |
|||
Which customer received the offer? What data and AI model were used? What discount policies applied? |
|||
2. **Interpret: Why did it happen?** |
|||
The AI recommended 20% because similar customers converted with discounts. But what if this customer was already willing to pay full price? |
|||
3. **Govern: Can we defend it?** |
|||
What if the AI offered 40% when company policy allows a maximum of 25%? Who approved it and why wasn't it blocked? |
|||
4. **Business Impact: Did it create value?** |
|||
The AI may have increased conversion rates but reduced profit margins by offering unnecessary discounts. |
|||
|
|||
> An AI decision can be technically correct, explainable and compliant, yet still produce a poor business outcome. |
|||
|
|||
|
|||
|
|||
### Practical Implementation Checklist |
|||
|
|||
✔ **Figure out what decisions your AI is making and how risky they actually are.** Some mistakes are easy to fix, others can cause serious problems. |
|||
✔ **Be clear about what AI can handle on its own** and what still needs a human to sign off. |
|||
✔ **Log what goes into each AI decision, what comes out,** which model was used and what information it relied on. You'll thank yourself later. |
|||
✔ **Don't just track AI accuracy.** Look at whether it's actually improving things like resolution times, customer satisfaction or costs. |
|||
✔ **Keep an eye on how your AI behaves in production**. Models can get worse over time, especially when the data changes. |
|||
✔ **Test how AI decisions would change under different scenarios** and check for potential bias when those decisions affect people. |
|||
✔ **Keep sensitive logs and decision records secure.** Make sure you know who can access them and how long they're stored. |
|||
✔ **Decide which information sources your AI should trust first.** You don't want it treating some random outdated document as the ultimate source of truth. |
|||
|
|||
--- |
|||
|
|||
## Building the Agentic Software Factory |
|||
|
|||
🧑**Speakers:** Thomas Dohmke (Founder of [Entire.io](https://entire.io/)) and Matan Grinberg (Cofounder of [Factory.com](https://factory.com/)) |
|||
|
|||
Before starting let's learn this term: **Agentic Software Factory**. AI-powered software development system where autonomous AI agents collaborate to design, build, test, deploy and maintain software applications with minimal human intervention. |
|||
|
|||
AI coding agents are cool but the real revolution isn't getting Claude or Codex to write more code. It's building an entire software development system that can plan, code, test, review, deploy and improve products with minimal human intervention. |
|||
|
|||
|
|||
|
|||
 |
|||
|
|||
[Entire](https://entire.io/) is created by Thomas Dohmke the former CEO of GitHub and it focuses on AI Agents + Human collaboration in software development. |
|||
|
|||
 |
|||
|
|||
|
|||
|
|||
## Key takeaways |
|||
|
|||
- **We're moving from AI coding assistants to autonomous software factories.** Instead of developers prompting agents for individual tasks, the goal is a continuous loop that turns customer feedback, incidents and product requirements into deployed improvements. |
|||
|
|||
- **Developers will increasingly build the factory, not just the software.** Engineering shifts toward designing workflows orchestrating agents, establishing quality controls and deciding what deserves human attention. |
|||
|
|||
- **AI-generated PR spam is a real problem.** Agents can generate hundreds of pull requests but humans can't realistically review them all. More generated code doesn't automatically mean more delivered value. |
|||
|
|||
- **Full autonomy is technically possible today but business readiness is another story.** New projects can be designed for autonomous development. Legacy enterprise systems are much harder because of complexity, security, compliance and organizational processes. |
|||
|
|||
- **Token economics matter.** Spending $5,000 on AI tokens to complete a task a developer could finish in five seconds is obviously ridiculous. Successful factories will optimize for business outcomes, not agent activity. |
|||
|
|||
- **Human oversight isn't disappearing.** The goal is to automate routine checks and low-risk changes while keeping engineers involved in critical architectural, security and product decisions. |
|||
|
|||
- **Developers aren't necessarily going away but their jobs are changing:** Curiosity, problem-solving, initiative and adaptability may matter more than years spent mastering a particular programming language. |
|||
|
|||
### Key Takeaways |
|||
|
|||
- **Build an agent workflow, not just a prompt library.** Define the inputs, expected outputs, tools, tests, review criteria and conditions for escalation to a human. |
|||
|
|||
- Introduce **risk-based auto-merging**. Allow well-tested, low-risk changes to merge automatically in a controlled pilot. Require human approval for security-sensitive, architectural and business-critical changes. |
|||
|
|||
- **Measure ROI (Return on Investment) instead of token consumption.** Track engineering hours saved, cost per accepted PR, deployment frequency, defect rates and review time. |
|||
|
|||
- **Connect agents to real customer signals.** Support tickets, telemetry, bug reports and feature requests should feed a prioritized engineering pipeline, not just sit in separate dashboards. |
|||
|
|||
- **Make failures improve the factory.** When an agent makes a mistake, add a regression test, architectural rule or automated check so the same mistake is less likely to recur. |
|||
|
|||
|
|||
--- |
|||
|
|||
## I Don't Trust AI Agents (And Neither Should You): Building Production-Ready Architectures |
|||
|
|||
🧑**Speakers:** Darko Mesaros (Distinguished Developer Advocate AWS) |
|||
|
|||
 |
|||
|
|||
The problem isn't that AI agents make mistakes. It's that developers give them too much freedom without building proper controls around them. |
|||
|
|||
The industry is spending a ridiculous amount of energy making agents smarter, while a lot of production problems are really about controlling what agents are allowed to do. |
|||
|
|||
The most useful idea in this talk isn't another fancy agent framework. It's treating the LLM as an untrusted component inside an otherwise well-engineered system. |
|||
|
|||
And I especially liked the point about not giving one giant agent 150 tools and hoping a massive system prompt will keep everything under control. |
|||
|
|||
- Don't trust agents to behave correctly just because you've written good system prompts. |
|||
- Build multiple security layers around agents: guardrails, steering, tool authorization, deterministic policies and observability. |
|||
- Never let an LLM decide who has access to sensitive data. Authorization belongs in your backend. |
|||
- High-risk operations should be blocked or require human approval. |
|||
- Avoid building one giant agent with 150 tools. Use specialized subagents with granular permissions. |
|||
- Trust the architecture surrounding the agent, not the agent itself. |
|||
|
|||
 |
|||
|
|||
|
|||
|
|||
### 1. Prompt engineering is not security |
|||
|
|||
You can tell an agent "*Never refund more than $500*" but that **doesn't guarantee it will obey**. |
|||
|
|||
He identifies three failure modes: |
|||
|
|||
- **Says something wrong:** Hallucinates information or promises something it cannot deliver. |
|||
- **Does something wrong:** Refunds money, deletes data or accesses the wrong customer's account. |
|||
- **Gets manipulated:** Prompt injection causes unintended behavior. |
|||
|
|||
The solution is defense in depth: several independent protection layers rather than trusting the LLM. |
|||
|
|||
### 2. Steering agents act as reviewers |
|||
|
|||
**A steering agent is a second LLM** that evaluates the main agent's response before it reaches the customer. |
|||
|
|||
For example, if the agent claims to have created a shortened return-label URL that it cannot actually generate, the steering agent rejects the response and provides corrective guidance. |
|||
|
|||
> You don't necessarily need a smarter main model. Sometimes adding an independent reviewer is more effective. |
|||
|
|||
### 3. Never trust LLM-generated tool parameters |
|||
|
|||
This is probably one of the most important technical points. |
|||
|
|||
Imagine a customer asks: |
|||
|
|||
> Show me order #67890. |
|||
|
|||
The LLM should not be trusted to determine whether that customer owns the order. |
|||
|
|||
Instead: |
|||
|
|||
- Authenticate the customer outside the LLM. |
|||
- Inject the authenticated customer ID into MCP calls using an interceptor. |
|||
- Enforce authorization deterministically in the backend. |
|||
- Return only data that customer is permitted to access. |
|||
|
|||
### 4. Put policy enforcement in front of tools |
|||
|
|||
The speaker demonstrates the [Dogwood policy language](https://aws.amazon.com/blogs/opensource/introducing-dogwood-runtime-verification-for-ai-agents/) to enforce business rules before MCP tools execute. This is an open-source AI security framework created by AWS https://github.com/dogwood-policy |
|||
|
|||
Examples: |
|||
|
|||
| Rule | Enforcement | |
|||
| ------------------------ | ------------------------------------- | |
|||
| Refund/return above $500 | Requires human review | |
|||
| Return label generation | Eligibility check must run first | |
|||
| Return eligibility | Must satisfy the 30-day return window | |
|||
| Customer order lookup | Must respect customer identity | |
|||
|
|||
The particularly interesting part is temporal policies. |
|||
|
|||
For example, the `generate_return_label` tool cannot execute unless `check_return_eligibility` has successfully run within the previous hour. That's much stronger than asking an LLM to remember the correct workflow. |
|||
|
|||
### 5. Observability is essential |
|||
|
|||
Production agents need more than basic application logs. |
|||
|
|||
The speaker recommends tracking: |
|||
|
|||
- Agent decisions and tool calls |
|||
- Tool selection accuracy |
|||
- Parameter selection accuracy |
|||
- Task success rates |
|||
- Harmful or incorrect outputs |
|||
|
|||
He also recommends periodically evaluating historical conversations, especially after changing prompts, models or tools. |
|||
|
|||
The key point: An agent's behavior can change even when your business logic hasn't. |
|||
|
|||
### 6. One giant agent is usually a bad architecture |
|||
|
|||
In the Q&A, Darko highlights a common mistake: building one agent with a huge prompt and access to 150 tools. |
|||
|
|||
Instead, use specialized agents with limited responsibilities. |
|||
|
|||
For example: |
|||
|
|||
- Returns Agent |
|||
- Customer Account Agent |
|||
- Order Status Agent |
|||
|
|||
Each agent should receive only the tools and permissions it needs. |
|||
|
|||
This makes agents easier to secure, evaluate and debug. |
|||
|
|||
 |
|||
|
|||
**Security Layers Architecture** |
|||
|
|||
|
|||
|
|||
 |
|||
|
|||
 |
|||
|
|||
|
|||
|
|||
 |
|||
|
|||
## Most interesting |
|||
|
|||
- The MCP Gateway becomes a security boundary. It's not just a convenient integration layer. It can enforce identity, tool access and policies independently of the model. |
|||
- Temporal policies are underrated. Enforcing what must happen before an action is a powerful way to control agent workflows. |
|||
- The speaker is essentially advocating traditional software engineering. Authentication, authorization, least privilege, logging and separation of responsibilities still matter. LLMs don't eliminate those requirements. |
|||
- Subagents are not just for better reasoning. They're also a way to isolate permissions and limit damage. |
|||
|
|||
|
|||
|
|||
--- |
|||
|
|||
|
|||
|
|||
## Securing AI Agent Infrastructure: Identity, Attestation and Trust at Scale |
|||
|
|||
🧑**Speaker:** Abdel Fane (Founder OpenA2A) |
|||
|
|||
 |
|||
|
|||
AI agents should be secured through infrastructure, not system prompts, because LLMs are unpredictable and vulnerable to prompt injection. The speaker recommends three essential security layers: |
|||
|
|||
1. **Identity** (every agent needs a verifiable identity tied to its owner) |
|||
|
|||
2. **Capabilities** (strict permissions defining exactly what tools, data and actions an agent can access) |
|||
|
|||
3. **Audit Trails** (tracking every action, including blocked attempts). |
|||
|
|||
|
|||
|
|||
He demonstrates how a malicious website can trick an AI agent into leaking sensitive information, while deterministic tool-level permissions can prevent it. |
|||
|
|||
> Treat agents like users with their own identities, enforce least-privilege access outside the LLM and log every action. Never rely on prompts alone to protect production systems. |
|||
|
|||
--- |
|||
|
|||
## Zero-Trust Architecture for Agentic AI: Securing Multi-User Access and Third-Party |
|||
|
|||
🧑**Speakers:** Borko Djurkovic (Member of Technical Staff Cohere) |
|||
|
|||
 |
|||
|
|||
AI agents must operate under Zero-Trust security principles, especially in multi-user enterprise environments. The speaker highlights three critical areas: |
|||
|
|||
1. **User authorization:** Combine RBAC (Role-Based Access Control) with ReBAC (Relationship-Based Access Control, using tools like OpenFGA) to control exactly which agents, models and tools each user can access. |
|||
|
|||
2. **Secure third-party integrations:** Use OAuth, delegated credentials and controlled MCP tool access so agents never exceed the permissions of the users they represent. |
|||
|
|||
3. **Secure RAG:** Remove sensitive information before indexing documents and enforce document- or chunk-level permissions during retrieval. |
|||
|
|||
> An agent must inherit the user's permissions, not bypass them. Every tool call and retrieved document should be independently authorized, regardless of what the LLM decides to do. |
|||
|
|||
|
|||
|
|||
--- |
|||
|
|||
## Give the Agent a Budget, Not a Token |
|||
|
|||
🧑**Speakers:** Sachin Malhotra (Platform Engineer Anthropic) |
|||
|
|||
 |
|||
|
|||
AI agents shouldn't receive unlimited permissions, even when performing legitimate tasks. Instead, give them controlled budgets for what they can do, how often and with what level of risk. Sachin Malhotra from Anthropic shares **a real incident where Claude accidentally deleted 200 workloads** belonging to 20 engineers in just 90 seconds. He recommends rate limits (restrict destructive actions per hour), asymmetric permissions (allow low-risk actions but require approval for dangerous ones), tripwires (monitor unusual behavior) and the Undo Test (if an action cannot be safely reversed, require human approval). Crucially, permissions must be enforced by infrastructure using independently verified agent identities, not prompts or agent-controlled credentials. |
|||
|
|||
> Give every agent its own identity, enforce action limits, monitor behavior and require human approval for high-risk operations. The goal isn't to eliminate every mistake but to limit the damage an agent can cause while preserving its autonomy. |
|||
|
|||
|
|||
|
|||
--- |
|||
|
|||
## From Model Selection to Smart Routing |
|||
|
|||
🧑**Speakers:** Viktoria Semaan (Principal Technical Evangelist at Databricks) |
|||
|
|||
 |
|||
|
|||
Using the most powerful LLM for every task is expensive and often unnecessary. Instead, AI systems should automatically select the most cost-effective model based on task complexity, quality, speed and cost. Victoria Ziman from Databricks recommends three approaches: |
|||
|
|||
1. **Model Evaluation:** Benchmark different models against real tasks, measuring accuracy, latency and cost per task. |
|||
|
|||
2. **AI Gateway:** Centralize model access, track spending, enforce budgets and support model switching and fallbacks. |
|||
|
|||
3. **Smart Routing:** Automatically assign simpler tasks to cheaper models and complex reasoning tasks to more powerful models. |
|||
|
|||
|
|||
|
|||
She also demonstrates [Omnigen](https://omnigent.ai/), a meta-harness that coordinates coding agents, selects models and controls execution budgets and retry limits. |
|||
|
|||
 |
|||
|
|||
> Implement intelligent model routing, per-agent budgets and continuous evaluation to reduce AI costs without significantly compromising quality. The goal isn't to use the best model everywhere, but the best model for each task. |
|||
|
|||
|
|||
|
|||
--- |
|||
|
|||
## Building AI Products vs. Building With AI |
|||
|
|||
🧑**Speakers:** Aparna Dhinakaran (Founder Arize), Rukmini Reddy (VP of Engineering PagerDuty), Tamar Bercovici (VP of Engineering Box) |
|||
|
|||
 |
|||
|
|||
AI is transforming software engineering from writing code to orchestrating AI agents, evaluating their outputs and ensuring production reliability. As code generation becomes cheaper and faster, engineering teams must rethink their workflows, responsibilities and infrastructure. The panel highlights four major shifts: |
|||
|
|||
1. **AI Software Factory:** Engineering teams are moving beyond individual coding assistants toward shared platforms where agents generate code, investigate bugs, analyze logs, create PRs and automate development workflows. |
|||
2. **Agent Harness & Evaluation:** Building reliable AI products requires adaptable agent harnesses, continuous evaluations, shared context, reusable skills and intelligent model selection. Teams must measure output quality rather than relying solely on traditional unit tests. |
|||
3. **AI-Powered Observability:** As AI-generated code increases, human code reviews alone cannot scale. AI agents can review other agents' activities, analyze traces, detect anomalies and identify production issues. Guardrails and controls to limit the impact of failures remain essential. |
|||
4. **Build vs. Buy:** AI makes custom software easier to build, but maintaining production-grade reliability, security, compliance and observability remains challenging. Companies should focus engineering resources on differentiating capabilities and consider buying specialized infrastructure. |
|||
|
|||
The speakers also emphasize that e**ngineers should treat agents like new team members**: when an agent produces poor results, improve its context, tools, instructions and skills rather than simply abandoning the task. |
|||
|
|||
> Move beyond AI-powered code generation toward an AI Software Factory with shared agent skills, reusable context, continuous evaluations, automated code reviews and production observability. The real competitive advantage is not generating more code but building a reliable system where humans and AI agents can continuously develop, test, deploy and maintain software together. |
|||
|
|||
|
|||
|
|||
--- |
|||
|
|||
## Making (and Breaking) Agents by Adding 1,000 MCP Tools |
|||
|
|||
🧑 Speaker: Guillaume Lebedev (Co-founder & CTO, StackOne) |
|||
|
|||
 |
|||
|
|||
Adding more MCP tools doesn't necessarily make AI agents more capable. It can actually break them by overwhelming their context windows, reducing tool-selection accuracy and increasing security risks. Guillaume Lebedev shows what happens when an agent is connected to 1,000 MCP tools and recommends four approaches: |
|||
|
|||
1. **Tool Search & Lazy Loading:** Instead of loading every MCP tool definition into the LLM's context, dynamically discover and load only relevant tools. His demo shows that loading hundreds of tools can consume approximately 440K tokens before the agent even starts working. |
|||
2. **Semantic Tool Discovery:** Traditional keyword-based search (BM25) can miss relevant tools or their prerequisites. Vector embeddings, semantic search and dependency graphs improve tool discovery accuracy and help agents find the correct sequence of operations. |
|||
3. **Context Optimization:** Use techniques such as Code Mode and Recursive Language Models (RLM) to process large tool responses without filling the agent's context window. This helps agents work efficiently with large amounts of external data. |
|||
4. **Prompt Injection Defense:** Every MCP tool response should be treated as potentially untrusted. Malicious instructions hidden in emails, CRM notes, meeting transcripts or support tickets can hijack agents. Combining specialized classifiers with LLM-based detection improves protection, but no detection method is perfect. |
|||
|
|||
He also demonstrates that tool discovery and prompt injection detection are classification problems, where specialized models can outperform simple keyword matching. However, the strongest protection remains deterministic access policies that prevent agents from calling unauthorized tools or accessing sensitive data. |
|||
|
|||
> Build a scalable MCP tool architecture with lazy tool loading, semantic tool discovery and dependency-aware tool selection. Optimize large tool responses to reduce context consumption and token costs. Most importantly, treat all external tool results as untrusted and enforce tool-level permissions outside the LLM. The goal isn't to give agents access to more tools, but to help them discover and safely use the right tools at the right time. |
|||
|
|||
--- |
|||
|
|||
|
|||
|
|||
## Context Engineering: How Machines Remember and Forget |
|||
|
|||
🧑 Speaker: Emre (Solutions Architect at OpenAI) |
|||
|
|||
 |
|||
|
|||
Context engineering is about providing AI agents with the right information at the right time, rather than filling their context windows with everything available. The speaker explains that long-running agents accumulate unnecessary tokens, outdated information and conflicting context, which can reduce accuracy and increase costs. He introduces three core strategies: |
|||
|
|||
1. **Reshape & Fit:** Optimize short-term context using trimming, compaction and summarization. Preserve important decisions and task progress while removing irrelevant conversation history and excessive tool outputs. |
|||
2. **Isolate & Route:** Use separate contexts and subagents to prevent information overload. Delegate specific tasks to agents with focused context rather than forcing one agent to process everything. |
|||
3. **Extract & Retrieve:** Build long-term memory that works across sessions. Extract meaningful information, store it persistently and retrieve only relevant memories when needed. |
|||
|
|||
He also emphasizes that memory should evolve rather than grow indefinitely. Agents must consolidate conflicting memories, forget outdated preferences and decide whether information should be loaded automatically or retrieved on demand. Evaluations (evals) are essential for measuring whether memory and context optimization actually improve performance, including testing agents with memory enabled versus disabled. |
|||
|
|||
> Build a dedicated Context & Memory Management layer that automatically summarizes long-running sessions, isolates subagent contexts and maintains persistent memory across sessions. Implement intelligent memory extraction, retrieval, consolidation and forgetting. Continuously evaluate context quality, token consumption and task success. The goal isn't to make agents remember everything, but to make them remember what matters and forget what doesn't. |
|||
|
|||
--- |
|||
|
|||
## Responsible AI Architecture with Zero Trust Agents |
|||
|
|||
**🧑 Speaker:** Ashok Prakash (Staff ML Engineer Apple) |
|||
|
|||
 |
|||
|
|||
Building an AI agent is easy, but making it safe, controllable, observable and production-ready requires a complete infrastructure architecture. The speaker identifies four major production risks: black-box decisions, silent model drift, unsafe actions and uncontrolled costs. He proposes an open-source, Zero-Trust reference architecture with five essential principles: |
|||
|
|||
1. Agent Controller & Execution Budgets: Run agents through controlled workflows (e.g., Temporal or Celery) with checkpoints, execution limits, token budgets and the ability to stop runaway agents. Prevent infinite reasoning loops and uncontrolled subagent execution. |
|||
2. Zero-Trust Tool Access: Treat tools and MCP integrations as contracted services with scoped identities, least-privilege permissions and just-in-time access. Agents must never access another user's data or retain permissions beyond their authorized scope. |
|||
3. Policy-Based Governance & Human Approval: Use deterministic policy engines such as Open Policy Agent (OPA) instead of relying on natural-language prompts. Classify actions into autonomous, human-assisted and human-only decisions, with structured approval requests for sensitive operations. |
|||
4. Responsible Data & Memory Management: Enforce consent tracking, PII redaction, data retention policies and user-scoped access. Isolate conversational memory from knowledge bases and maintain source traceability to detect and recover from poisoned data. |
|||
5. Observability, Evaluation & Safe Deployment: Use OpenTelemetry to track agent decisions, costs and failures. Continuously monitor model drift, version models and RAG datasets and deploy through evaluation gates, shadow testing, canary releases and gradual rollouts. |
|||
|
|||
The speaker also highlights KServe and vLLM for model serving, caching, autoscaling and cost optimization. His central architectural principle is that safety must be enforced throughout the infrastructure, not added as a final layer. |
|||
|
|||
> Build a Zero-Trust Agent Runtime with centralized execution control, scoped tool permissions, deterministic policies, human approval workflows and end-to-end observability. Add execution budgets, versioned agent configurations, continuous evaluations and safe deployment mechanisms. The goal is not simply to create autonomous agents, but to make their behavior predictable, auditable, recoverable and safe enough for enterprise production. |
|||
|
|||
--- |
|||
|
|||
## Rethinking Developer Tools for the Agent Era |
|||
|
|||
🧑 Speakers: Ben Helle (Chief Product Officer, Webflow), Han Wang (Co-founder, Mintlify), Sam Bhagwat (Founder & CEO, Mastra) |
|||
|
|||
 |
|||
|
|||
AI agents are becoming primary users of developer tools, forcing companies to rethink product design, documentation, APIs and developer experience. Webflow reports that the majority of its MCP-driven content development activity now involves agents, while Mintlify reports that agent traffic increased from approximately 2–3% in early 2025 to 67%. The speakers highlight four major shifts: |
|||
|
|||
1. **Developer Experience (DX) → Agent Experience (AX):** Developer tools must increasingly serve AI agents alongside humans. Agent-friendly APIs, MCP servers, CLI interfaces, skills files and documentation are becoming important product capabilities. |
|||
2. **Agent Discovery & Adoption:** Agents increasingly discover, evaluate and recommend developer tools. Clear documentation, accurate technical information and well-designed SDKs influence whether agents successfully adopt a product. However, great human developer experience often translates into great agent experience. |
|||
3. **Task-Oriented MCP & Shared Skills:** Simply exposing REST APIs through MCP isn't enough. Tools should support meaningful workflows and human goals. Teams also need centralized, reusable agent skills to produce consistent results across multiple agents. |
|||
4. **Humans Become Agent Managers:** Developers are shifting from writing every line of code to coordinating teams of agents. The most valuable human skills become product judgment, customer empathy, problem identification and the ability to design effective agent workflows. |
|||
|
|||
The panel also discusses how AI dramatically reduces the cost of building software but doesn't automatically make products successful. Finding product-market fit, understanding customers and building something people genuinely love remain difficult. |
|||
|
|||
> Treat AI agents as first-class users of your products. For ABP, invest in agent-friendly documentation, MCP integrations, CLI capabilities, reusable skills and task-oriented workflows. Focus on human-agent collaboration, shared skills and managing teams of agents. The opportunity is no longer just helping developers write code faster, but enabling humans to manage agents that build software for them. |
|||
|
|||
|
|||
|
|||
--- |
|||
|
|||
## Your Next Customer Won’t Be Human |
|||
|
|||
🧑 Speaker: Ben Smith (Staff Developer Advocate at Stripe) |
|||
|
|||
 |
|||
|
|||
AI agents are becoming economic actors: they will not only discover and purchase products on behalf of humans, but also autonomously pay for APIs, tools, compute and services to complete tasks. Traditional websites and checkout flows are designed for humans, while agents need structured data, discoverable APIs, standardized protocols and secure payment mechanisms. Ben Smith from Stripe highlights four major developments: |
|||
|
|||
1. **Agentic Commerce & Agent Experience:** Businesses must make their products and services discoverable and purchasable by AI agents. Structured product catalogs, clear constraints, APIs and machine-readable information become essential. |
|||
2. **Universal Commerce Protocol (UCP):** A standardized protocol that allows agents to discover merchants, browse products, create checkouts and complete purchases without building custom integrations for every merchant. Merchants expose their capabilities through `/.well-known/ucp`. |
|||
3. **Secure Agent Payments:** Stripe's Shared Payment Tokens (SPT) allow agents to initiate purchases without exposing raw payment credentials to merchants. Tokens can be restricted by merchant, spending amount, expiration and usage. |
|||
4. **Machine Payments Protocol (MPP):** Enables machine-to-machine payments using HTTP `402 Payment Required`. Agents can automatically pay for APIs, MCP tools, storage, compute and other services on demand, without requiring users to manually create accounts or manage API keys. |
|||
|
|||
The speaker demonstrates an AI shopping assistant that discovers products, recommends options, calculates shipping and taxes and completes a purchase. He also shows how changing an agent's instructions can turn a helpful shopping assistant into a misleading salesperson, emphasizing the importance of responsible agent behavior. |
|||
|
|||
> Prepare for an agent-to-agent economy where agents can discover, purchase and consume external capabilities autonomously. Consider per-agent wallets, spending limits, payment approvals and usage tracking to support agents purchasing APIs, MCP tools and services. For ABP, explore agent-friendly service discovery and standardized commerce integrations. The next generation of software won't just serve human users; it will also serve AI agents that can independently discover, access and pay for capabilities. |
|||
|
|||
--- |
|||
|
|||
## The Browser Is Becoming an AI Runtime |
|||
|
|||
🧑 Speakers: Ajit Varma (Head of Firefox, Mozilla), Will Burke (Founder & CEO, Exa), Julia Love (Technology Reporter, Bloomberg , Moderator) |
|||
|
|||
 |
|||
|
|||
Browsers are evolving from tools humans use to navigate websites into AI runtimes where agents search, understand and interact with the internet on our behalf. Mozilla and Exa envision an open, agent-friendly web where users can choose their AI models, preserve their browsing context and avoid dependence on a single AI provider. The speakers highlight four major shifts: |
|||
|
|||
1\. **Browser as an AI Runtime:** Browsers are becoming execution environments for agents. Instead of simply displaying websites, they enable AI to navigate pages, interpret content, make decisions and perform actions. Some agent systems already use cloud-hosted browsers running inside virtual machines. |
|||
|
|||
2\. **AI Choice & Model Independence:** Mozilla's Firefox Smart Windows approach allows users to choose between AI providers, including open and privacy-focused models, while maintaining their browsing context. This reduces vendor lock-in and supports AI sovereignty. |
|||
|
|||
3\. **Search Built for Agents:** Exa is developing search infrastructure specifically for AI agents rather than humans. Will Burke predicts that AI-generated searches could surpass human searches by early 2027, creating a fundamentally different market for information retrieval. |
|||
|
|||
4\. **A New Economy for Web Content:** Traditional search relies heavily on advertising and human clicks. AI agents increasingly consume information without visiting websites, threatening publishers' existing business models. Exa proposes a model where agents pay data providers directly for high-quality information, including through its Exa Connect offering. |
|||
|
|||
The panel also emphasizes open web standards, publisher consent, source attribution and user control. Websites are still primarily designed for humans, but agents increasingly interact with them through browser automation, visual recognition and emerging protocols such as MCP. |
|||
|
|||
> Treat browser automation as a core agent capability, alongside APIs and MCP tools. Consider isolated browser sessions where agents can navigate websites, perform tasks and request human approval for sensitive actions. For ABP, make applications accessible to both humans and agents through structured interfaces, APIs and agent-friendly workflows. The future browser won't just display applications; it will become an execution environment where AI agents operate applications on behalf of users. |
|||
|
|||
--- |
|||
|
|||
|
|||
|
|||
## Going Beyond the Code Through the GitHub Copilot App: How to Unlock You and Your Team’s Superpower |
|||
|
|||
🧑 Speaker: Jenny Huang (Director of User Research, GitHub) |
|||
|
|||
 |
|||
|
|||
AI coding agents have removed the bottleneck of writing code, but the bottleneck has shifted to coordination, context switching and deciding what to build. Jenny Huang explains that software productivity is no longer just about generating code faster. It's about connecting information, reducing fragmented workflows and helping people move from ideas to valuable outcomes. She demonstrates three practical applications of the GitHub Copilot app: |
|||
|
|||
1. Product Feedback & Prioritization: Aggregate thousands of feedback signals from GitHub Issues, customer surveys, telemetry and other sources. Use AI to identify patterns, understand customer needs and prioritize product development based on evidence rather than scattered discussions. |
|||
2. Customer Context & Sales Readiness: Connect information from multiple business systems to create a unified customer overview. Sales teams can prepare for meetings, understand customer relationships and identify opportunities without manually searching across different applications. |
|||
3. Research & Content Creation: Transform raw data, transcripts and external research into actionable insights and working applications. The VS Code team demonstrates using Copilot to research podcast topics and build an analytics dashboard from podcast engagement data. |
|||
|
|||
She emphasizes that AI-powered workflows should extend beyond developers to product managers, researchers, sales teams and other business users. The objective is to preserve human creativity and judgment while automating repetitive information gathering and coordination. |
|||
|
|||
> Think beyond AI-assisted coding and build a unified human-agent workspace that connects development, product management, customer feedback and business operations. Prioritize cross-application context sharing, collaborative workflows and agents that turn scattered information into actionable tasks. For ABP Studio AI Agent, consider integrating product requirements, documentation and user feedback directly into development workflows. The next productivity breakthrough won't come from generating more code, but from reducing the coordination overhead between humans, agents and tools. |
|||
|
|||
--- |
|||
|
|||
## Why Buy Software When AI Can Build It? |
|||
|
|||
🧑**Speakers:** Lee Edwards (General Partner at Root Ventures), Mang-Git Ng (CEO of Anvil), Richard Robinson (Chief Evangelist at UnqorkAI) |
|||
|
|||
 |
|||
|
|||
AI is making software cheaper to build but not necessarily cheaper to operate, secure, scale and maintain. That's where software companies can still win. |
|||
|
|||
- Building an MVP is becoming trivial. Getting software production-ready is still difficult. |
|||
- Traditional SaaS is under pressure. Customers are starting to build tools themselves rather than paying subscriptions. |
|||
- Developer experience is changing. A great UI may no longer be enough. AI-friendly APIs, CLIs, MCP integrations and documentation are becoming competitive advantages. |
|||
- AI agents are becoming software buyers and decision-makers. They increasingly recommend which tools, databases and platforms developers should use. |
|||
- Software companies need stronger differentiation. Security, compliance, scalability, reliability and domain expertise matter more than basic features. |
|||
- The future may involve fewer dashboards. Users could interact with personal agents rather than traditional SaaS interfaces. |
|||
|
|||
## Main arguments |
|||
|
|||
### 1. The economics of Buy vs. Build have fundamentally changed |
|||
|
|||
Historically, buying software was often cheaper than building and maintaining it. AI is shifting that calculation. |
|||
|
|||
This is particularly concerning for developer tools that primarily monetize convenience, hosting or ease of setup. |
|||
|
|||
However, the panel agrees that building something and operating it reliably are very different problems. |
|||
|
|||
### 2. MVPs are no longer a competitive advantage |
|||
|
|||
Getting a prototype working is easy. Getting it into production and supporting thousands of customers is still hard. |
|||
|
|||
AI is good at fixing problems once they are identified but panelists argue it remains less reliable at anticipating scaling problems before they occur. |
|||
|
|||
The competitive advantage is shifting: |
|||
|
|||
OLD DIFFERENTIATION |
|||
|
|||
Build software faster |
|||
|
|||
- Rapid development |
|||
- Easy UI |
|||
- More features |
|||
- Quick prototypes |
|||
|
|||
NEW DIFFERENTIATION |
|||
|
|||
Ship reliable software faster |
|||
|
|||
- Production readiness |
|||
- Security and compliance |
|||
- Scalability |
|||
- Ongoing maintenance |
|||
|
|||
### 3. Your next customer might be an AI agent |
|||
|
|||
Lee Edwards describes how Claude recommended Railway and Neon for his projects. The developer didn't independently discover these products. The AI selected them based on the project's requirements. |
|||
|
|||
Anvil's CEO also explains that their strong documentation helps AI agents recommend Anvil over competing PDF and e-signature solutions, generating inbound interest. |
|||
|
|||
As a result: |
|||
|
|||
- Documentation becomes a marketing channel. |
|||
- MCP servers and CLIs become product discovery and adoption channels. |
|||
- Being recommended by AI assistants may become as important as ranking on Google. |
|||
|
|||
This doesn't mean traditional SEO disappears but software companies increasingly need to optimize for both human and AI-driven discovery. |
|||
|
|||
### 4. SaaS might disappear from the UI, not the infrastructure |
|||
|
|||
Lee Edwards suggests a future where people stop opening multiple SaaS dashboards. |
|||
|
|||
Instead of logging into Salesforce to review sales activity, someone might ask their personal AI agent for an update. |
|||
|
|||
This creates two distinct risks for SaaS companies: |
|||
|
|||
- Customers build their own replacement software. |
|||
- Customers stop using traditional applications directly because agents handle the interactions. |
|||
|
|||
He also suggests that systems of record and foundational infrastructure may retain stronger competitive positions. |
|||
|
|||
### 5. Companies should buy what doesn't differentiate them |
|||
|
|||
Anvil's CEO makes a practical argument: Why spend months building PDF generation when that functionality has already been solved, tested and scaled by a specialist provider? |
|||
|
|||
The same logic applies to security, infrastructure and other standardized capabilities. |
|||
|
|||
Build the functionality that makes your business unique. Buy or reuse the capabilities that don't. |
|||
|
|||
AI reduces implementation cost but it doesn't eliminate the value of mature, specialized software. |
|||
|
|||
## 2. What Can We Do for ABP? |
|||
|
|||
|
|||
|
|||
| Priority | Opportunity | Recommended action | |
|||
| -------- | --------------------------------- | ------------------------------------------------------------ | |
|||
| High | AI-driven discovery | Make ABP documentation easier for AI agents to discover, interpret and recommend | |
|||
| High | Production readiness | Emphasize secure, maintainable, production-ready applications rather than just faster development | |
|||
| High | Agent-native developer experience | Make ABP Studio capabilities accessible through agent-friendly tools and interfaces | |
|||
| Medium | Competitive positioning | Explain why AI-generated code still benefits from ABP architecture and modules | |
|||
| Medium | Marketing | Publish AI coding workflows demonstrating the value of ABP alongside coding agents | |
|||
|
|||
|
|||
|
|||
The below message shifts the value proposition from code generation to the engineering foundations required to deliver reliable applications. |
|||
|
|||
## AI can write your code. ABP helps you ship production-ready applications. |
|||
|
|||
> **The whole "AI will kill SaaS" argument is way too simplistic.** |
|||
|
|||
Sure, Claude can build a CRM prototype in an afternoon. But who's going to maintain it, secure it, handle migrations, deal with compliance and keep it running when the business grows? |
|||
|
|||
That's the actual business opportunity. |
|||
|
|||
> **AI agents becoming the ones choosing software.** |
|||
|
|||
Imagine spending years optimizing your website for developers, only to discover that the developer now asks Claude which framework to use. |
|||
|
|||
Suddenly, documentation, APIs, CLI and MCP integrations become part of your marketing strategy. |
|||
|
|||
> **Don't compete with AI on how quickly it can generate code.** Compete on everything required to turn that code into dependable software. |
|||
|
|||
*Can we make ABP the preferred foundation for AI-generated enterprise applications, rather than positioning it as an alternative to AI coding?* 👊 **YES** |
|||
|
|||
|
|||
|
|||
## NETWORKING |
|||
|
|||
 |
|||
|
|||
 |
|||
|
|||
## ROUNDTABLE: Running AI Agents at Scale |
|||
|
|||
What's actually breaking in production agent deployments, from visibility and governance to cost control at scale and what a real governance layer for agentic AI needs to look like. We gathered to talk the topic: "Running AI Agents at Scale". We were 15 senior engineering and technical leaders facing the same problems. It was hosted by James Everingham, CEO and Co-founder of Guild.ai. I couldn't remember everyone's name in the meeting but as I remember there were Ankit Patel from NVIDIA, Yifei Liu from Vectra AI, Phani Pendurthi from Mastercard, from Oracle and Devin AI. |
|||
|
|||
 |
|||
|
|||
### Roughly We Talked About |
|||
|
|||
* There should be lots of alerts in an agentic system. For budget, security... For example if an agent runs too long or it retrieves too much data, be alerted. |
|||
* There should be an **AI Kill Switch** toggle somewhere. We don't know when we'll hack, abuse or unwanted agent runs... |
|||
* Permissions are crucial! Agents must be allowed with scoped access to the tools, data, APIs. |
|||
* Agents should have role-based authentication. |
|||
* AI firewalls are another security layer which protect how AI agents interact with users, tools, data and other systems. For example [Cloudflare AI Security](https://www.cloudflare.com/solutions/ai-security/) What an AI firewall does: |
|||
* Prompt Injection: Block malicious instructions hidden in documents, emails or web pages. |
|||
* Data Leakage: Prevent agents from exposing API keys, credentials or sensitive customer information. |
|||
* Tool Call Validation: Block unauthorized or suspicious MCP tool calls. |
|||
* Content Filtering: Detect harmful or policy-violating inputs and outputs. |
|||
* Anomaly Detection: Flag unusual agent behavior, such as excessive API calls or bulk data exports. |
|||
* For MCP tools, we should apply least-privilege access, allowing agents to discover and execute only the tools they need for their specific tasks. |
|||
* Who's accountable for the things that AI does? Simply humans. An agent must be under control of someone (who created or who initiates) and that person must be accountable for any issues. |
|||
* Auditing is more important now! If don't trace the agent's work, we cannot find the accountable person, measure the outputs, costs, running durations, data breaches etc... |
|||
* Using sandbox is a best practise. |
|||
* AI agents are not for free! To manage your budget, you need to set upper limits per your agent, project, team, task. |
|||
* Human in the loop but when?! If an AI agent asks for human approval at every step, automation loses its value. Everything slows down and humans become the bottleneck. |
|||
* **Impact**: How significant are the consequences of the action? |
|||
* **Reversibility**: Can the action be easily undone? |
|||
* **Confidence**: How confident is the AI in its decision? |
|||
* **Risk**: What are the potential financial, security, legal, health or reputational risks? |
|||
* **Authority**: Is the action within the AI agent's permitted scope? |
|||
|
|||
> The higher the impact, the lower the reversibility and the greater the uncertainty, the more important human oversight becomes. |
|||
|
|||
For example, an AI agent can draft an email without approval but sending an email to 10,000 customers might require human confirmation. |
|||
|
|||
### Another topic we discussed: Agent Access Control |
|||
|
|||
AI agents shouldn't have permanent access to everything. Instead, they should receive only the permissions they need, exactly when they need them and only for as long as necessary. This is called Just-in-Time (JIT) Access. For example, an AI agent processing a refund might temporarily get permission to issue that refund, but lose it immediately afterward. This minimizes security risks, limits the damage from compromised agents and allows organizations to scale AI safely without giving agents excessive privileges. |
|||
|
|||
**Just-in-Time Access:** AI agents shouldn't have permanent access to sensitive systems. Instead, they request permissions when needed and a centralized access management system grants temporary access based on predefined security policies. Humans define the rules and the system enforces them automatically. This reduces security risks, limits potential damage and allows AI agents to operate at scale without requiring human approval for every action. |
|||
|
|||
For example, a system administrator defines the following rules: |
|||
|
|||
- An AI agent can issue refunds up to $100. |
|||
- Refunds are allowed only for customers assigned to the agent. |
|||
- Access is granted temporarily for a single transaction. |
|||
- Refunds exceeding $100 require human approval. |
|||
|
|||
When the agent requests access, the system evaluates these predefined policies and grants temporary permissions only if the conditions are met. |
|||
|
|||
--- |
|||
|
|||
## Whole Summary |
|||
|
|||
- Move beyond AI coding assistants toward AI Software Factories, where agents collaborate to build, test, review and deploy software. |
|||
- Run AI agents in isolated sandboxes with dedicated identities, limited permissions and controlled budgets. |
|||
- Apply Zero-Trust security with deterministic policies, audit trails and human approval for high-risk actions. |
|||
- Choose AI models based on cost per successful task, using smart routing and continuous evaluations. |
|||
- Invest in context engineering and long-term memory to improve agent performance and reduce costs. |
|||
- Make observability and automated evaluations essential parts of production AI systems. |
|||
- Use specialized agents with focused responsibilities instead of giving one agent access to hundreds of tools. |
|||
- Design documentation, APIs, CLIs and MCP tools for AI agents, not just human developers. |
|||
- Prepare for an agent-driven economy where AI agents discover, recommend, use and purchase software. |
|||
- Focus on production readiness, security, scalability and maintainability as AI makes code generation increasingly accessible. |
|||
- Shift developers' focus from writing code to orchestrating agents, solving problems and making architectural decisions. |
|||
- Keep investing in junior developers and human expertise, because judgment, creativity and understanding what to build remain essential. |
|||
|
|||
And lastly, I agree 100% to the following saying. |
|||
|
|||
> **AI LEARNT CODING NOW IT'S CHEAP. LET'S LEARN MARKETING** |
|||
|
|||
 |
|||
|
|||
|
|||
|
|||
--- |
|||
|
|||
## Volobox |
|||
|
|||
I also have chance to explain our new product [Volobox.io](https://volobox.io) to some attendees. Everyone likes the idea and implementation details. |
|||
|
|||
> Context is the new king! |
|||
|
|||
AI models are getting smarter. But the real game-changer is context. That's why Volobox brings chats, meetings, tasks, files and AI agents into one shared context. No need to copy-paste from different apps, environments. Just AI agents that understand your work; Get things done... |
|||
|
|||
 |
|||
|
|||
|
|||
|
|||
## About My Trip in San Francisco & Los Angeles |
|||
|
|||
Some pictures from my trip. |
|||
|
|||
 |
|||
|
|||
 |
|||
|
After Width: | Height: | Size: 2.1 MiB |
|
After Width: | Height: | Size: 747 KiB |
|
After Width: | Height: | Size: 8.2 MiB |
|
After Width: | Height: | Size: 15 KiB |
|
After Width: | Height: | Size: 992 KiB |
|
After Width: | Height: | Size: 180 KiB |
|
After Width: | Height: | Size: 212 KiB |
|
After Width: | Height: | Size: 521 KiB |
|
After Width: | Height: | Size: 1000 KiB |
|
After Width: | Height: | Size: 12 KiB |
|
After Width: | Height: | Size: 258 KiB |
|
After Width: | Height: | Size: 450 KiB |
|
After Width: | Height: | Size: 683 KiB |
|
After Width: | Height: | Size: 614 KiB |
|
After Width: | Height: | Size: 396 KiB |
|
After Width: | Height: | Size: 1004 KiB |
|
After Width: | Height: | Size: 914 KiB |
|
After Width: | Height: | Size: 1.0 MiB |
|
After Width: | Height: | Size: 43 KiB |
|
After Width: | Height: | Size: 21 KiB |
|
After Width: | Height: | Size: 1010 KiB |
|
After Width: | Height: | Size: 2.7 MiB |
|
After Width: | Height: | Size: 2.7 MiB |
|
After Width: | Height: | Size: 1.7 MiB |
|
After Width: | Height: | Size: 1.7 MiB |
|
After Width: | Height: | Size: 1.9 MiB |
|
After Width: | Height: | Size: 2.6 MiB |
|
After Width: | Height: | Size: 2.4 MiB |
|
After Width: | Height: | Size: 127 KiB |
|
After Width: | Height: | Size: 492 KiB |
|
After Width: | Height: | Size: 272 KiB |
|
After Width: | Height: | Size: 408 KiB |
|
After Width: | Height: | Size: 759 KiB |
|
After Width: | Height: | Size: 56 KiB |
|
After Width: | Height: | Size: 1.1 MiB |
|
After Width: | Height: | Size: 123 KiB |
|
After Width: | Height: | Size: 101 KiB |
|
After Width: | Height: | Size: 168 KiB |
|
After Width: | Height: | Size: 1.2 MiB |
|
After Width: | Height: | Size: 255 KiB |
|
After Width: | Height: | Size: 780 KiB |
|
After Width: | Height: | Size: 522 KiB |
|
After Width: | Height: | Size: 3.2 MiB |
|
After Width: | Height: | Size: 2.1 MiB |
|
After Width: | Height: | Size: 14 KiB |
|
After Width: | Height: | Size: 11 MiB |
|
After Width: | Height: | Size: 259 KiB |
|
After Width: | Height: | Size: 433 KiB |
|
After Width: | Height: | Size: 471 KiB |
|
After Width: | Height: | Size: 711 KiB |
|
After Width: | Height: | Size: 479 KiB |
|
After Width: | Height: | Size: 533 KiB |
|
After Width: | Height: | Size: 508 KiB |
|
After Width: | Height: | Size: 487 KiB |
|
After Width: | Height: | Size: 430 KiB |
|
After Width: | Height: | Size: 400 KiB |
|
After Width: | Height: | Size: 440 KiB |
|
After Width: | Height: | Size: 594 KiB |
|
After Width: | Height: | Size: 413 KiB |
|
After Width: | Height: | Size: 390 KiB |
|
After Width: | Height: | Size: 331 KiB |
|
After Width: | Height: | Size: 412 KiB |
|
After Width: | Height: | Size: 489 KiB |
|
After Width: | Height: | Size: 278 KiB |
|
After Width: | Height: | Size: 333 KiB |
|
After Width: | Height: | Size: 447 KiB |
|
After Width: | Height: | Size: 383 KiB |
|
After Width: | Height: | Size: 426 KiB |
|
After Width: | Height: | Size: 560 KiB |
|
After Width: | Height: | Size: 303 KiB |
|
After Width: | Height: | Size: 905 KiB |
|
After Width: | Height: | Size: 550 KiB |
|
After Width: | Height: | Size: 429 KiB |
@ -0,0 +1,798 @@ |
|||
# Reviews of DevAI Conference From a Speaker’s Eye |
|||
|
|||
Last week **I traveled to Poland** for a conference just dedicated to AI. I see that there will more conferences in the future targeting **just AI topics**. This's the trend now! I'm happy that, I catched the last good weather period in Warsaw before winter comes. So for me it was a conference at the same time learning some cultural information about Poland's history, city life, people and developer's mindset. |
|||
|
|||
DevAI by Data Science Summit 2026, the official website https://devai.dssconf.pl, took place in two distinct parts: Monday, October 19 online and Tuesday onsite at the [Copernicus Science Centre](https://www.google.com/maps/place/Copernicus+Science+Centre/@52.2418552,21.0287271,17z/data=!3m1!4b1!4m6!3m5!1s0x471ecc5ba250ccd1:0x8d6f1b9b8410960!8m2!3d52.2418552!4d21.0287271!16s%2Fm%2F05mwh1p?entry=ttu&g_ep=EgoyMDI2MTAyMC4wIKXMDSoASAFQAw%3D%3D) in Warsaw. |
|||
|
|||
 |
|||
|
|||
There were **50 presentations across 4 tracks**. Sessions were 35-minute long, roundtables, speaker Q&A, networking, an Expo and an afterparty. The audience was explicitly broader than developers alone, extending to architects, DevOps/infrastructure engineers, AI engineers, managers, directors and C-level leaders. In the afterparty, they organized some games to make networking. There were 4 different tables. You stand at a table, and someone from the table asks question. For example: "*what's the most absurd security precaution that your company took?*" and people at the table answers. 10 mins later the organizator comes and switches table so that you meet new people. By doing so, people knows each other. |
|||
|
|||
I had the chance to talk to several developers at the conference. **One thing that surprised me** was how few of them were working with .NET. Most of the developers I met were using Python, JavaScript or Java. Of course, this is just my observation from a few conversations, not a reflection of the entire Polish developer community. So l look up internet to see a statistics about Polish IT people language spectrum and here's the results... |
|||
|
|||
 |
|||
|
|||
## **“Look what AI can generate!” Period Finished** |
|||
|
|||
Until now, we have been surprised about AI assisted development, tools and AI generated outputs. I guess this time has already completed. Yes we see using AI is productive and impressive but hat happens after an exciting AI-based MVP or demo? We started to ask questions about the following topics: |
|||
|
|||
* observability |
|||
|
|||
* reliability |
|||
|
|||
* security |
|||
|
|||
* cost control |
|||
|
|||
* verification |
|||
|
|||
* human oversight |
|||
|
|||
* production debugging |
|||
|
|||
* deterministic retrieval |
|||
|
|||
* organizational implications |
|||
|
|||
|
|||
|
|||
> **The biggest shift is from “WHAT CAN AI BUILD?” ** |
|||
> |
|||
> **👉 “HOW DO WE MAKE AI-GENERATED WORK TRUSTHWORTHY ENOUGH TO SHIP?** |
|||
|
|||
|
|||
|
|||
|
|||
|
|||
--- |
|||
|
|||
## My Talk |
|||
|
|||
My session, “Talk With Your Data: Building AI-Powered Reporting,” ran from 12:55–13:30 in Room 2, followed by a dedicated **Ask-a-Speaker slot at 13:35–13:50**. I covered my hands-on experiences on AI reporting, transforming human language to database queries, visualizing the output and getting insights directly from your database. I have a simple prediction for the future; the application UIs will be mostly eliminated and 👇 |
|||
|
|||
> **AI will be a conversational interface for the applications!** |
|||
|
|||
 |
|||
|
|||
 |
|||
|
|||
--- |
|||
|
|||
|
|||
|
|||
## Sessions I Attended and What I Learnt |
|||
|
|||
# How AI-Native Development Is Reshaping Software Teams |
|||
|
|||
**Speaker:** Bartosz Fijałkowski |
|||
|
|||
 |
|||
|
|||
### 1. Real-World Results |
|||
|
|||
 |
|||
|
|||
In their company, they transformed a 10+ year-old Java recruitment system to **.NET 10 + Blazor + PostgreSQL** stack. |
|||
|
|||
- **19 working days** to a functional platform. |
|||
- **10 weeks** to production vs. an estimated 7–9 months traditionally. |
|||
- **69 changes** delivered after adopting the new process. |
|||
|
|||
### 2. Spec-Driven Development Is the Key |
|||
|
|||
 |
|||
|
|||
Unstructured prompting creates unpredictable results. Their approach follows: |
|||
|
|||
**Business Problem → Specification → Plan → Small Tasks → Code & Tests** |
|||
|
|||
Every stage includes human approval. AI generates code based on clear specifications rather than vague prompts. |
|||
|
|||
I hate terminology as it makes people's mind confusing. When people tell spec-driven development, it looks like there's a new AI development approach coming up in 2026. No it's just a naming which we already do in all our development life. Spec-Driven Development = Giving Details of What You Want. |
|||
|
|||
**Vibe Coding:** |
|||
|
|||
> "Hey AI, build me a shopping website." |
|||
|
|||
AI writes code. You look at the result and ask for changes until you're happy. |
|||
|
|||
**Spec-Driven Development:** |
|||
|
|||
> "Let's first define exactly what this shopping website should do, how it should work and how we'll know it's correct. Then implement it." |
|||
|
|||
### 3. Standardize Architecture and Engineering Rules |
|||
|
|||
 |
|||
|
|||
They use reusable repository templates with predefined architecture, CI/CD, technology skills and coding standards. |
|||
|
|||
**Modular monolith is the default.** Complex architectures must be justified. |
|||
|
|||
### 4. AI Changes Team Structure |
|||
|
|||
 |
|||
|
|||
Traditional front-end, back-end and DevOps responsibilities merge into broader software engineering roles. |
|||
|
|||
Their proposed AI-native team has **5 people instead of 13**: one lead, one analyst, two engineers and QA automation. Java developers started to code with .NET. |
|||
|
|||
### 5. Coding Is No Longer the Bottleneck |
|||
|
|||
 |
|||
|
|||
AI accelerates implementation but requirements and testing become the new bottlenecks. |
|||
|
|||
Their project includes **1,531 automated tests** running in approximately 7 seconds and **281 API parity tests**. |
|||
|
|||
### 6. Faster Development Creates New Challenges |
|||
|
|||
- **Knowledge management:** Specifications, decisions and an LLM Wiki help teams share knowledge and onboard developers. |
|||
|
|||
- **Scaling:** Add complete, balanced teams (pods) rather than individual developers. |
|||
|
|||
- **Prioritization:** Faster delivery brings back previously postponed ideas, potentially increasing the backlog. |
|||
|
|||
|
|||
|
|||
> **AI-native development isn't just about generating code faster. It's about redesigning the entire software development process.** The biggest gains come from combining structured specifications, standardized architecture, AI agents, automated testing and human oversight. |
|||
|
|||
|
|||
|
|||
--- |
|||
|
|||
# Retrofitting Agentic RAG: Making Retrieval More Deterministic |
|||
|
|||
**Speaker:** Jan Majewski, Lead AI Engineer at Minerva |
|||
|
|||
Jan Majewski shared how his team improved RAG for matching products across different domains, languages and large document collections. The session focused on making RAG more deterministic, scalable and cost-efficient by combining traditional NLP techniques with LLMs. |
|||
|
|||
 |
|||
|
|||
### 1. Traditional RAG Struggles with Domain-Specific Terminology |
|||
|
|||
Different clients describe the same products using completely different terminology. For example, finding fentanyl in procurement documents may require searching for **30+ different keywords**. |
|||
|
|||
A relevant document for one client might be irrelevant for another. This makes conventional keyword search and vector similarity insufficient for reliable matching. |
|||
|
|||
 |
|||
|
|||
### 2. Extract Information Once, Search Many Times |
|||
|
|||
Instead of repeatedly searching thousands of documents for every client query, their approach processes documents once and extracts relevant product entities. The extracted information is organized into a structured, graph-like product registry. Future queries search this registry rather than repeatedly processing the original documents. |
|||
|
|||
 |
|||
|
|||
### 3. Combine Named Entity Recognition with LLM Validation |
|||
|
|||
Their approach, called **NER-RAG**, combines traditional NLP with LLMs: |
|||
|
|||
- **NER models** extract product names and relevant entities from documents. |
|||
- **Hybrid search** identifies potential matches from the extracted entities. |
|||
- **Rerankers and LLMs** validate ambiguous matches. |
|||
- **Human feedback and LLM-generated labels** help improve NER models over time. |
|||
|
|||
This reduces unnecessary LLM calls while making retrieval more predictable. |
|||
|
|||
 |
|||
|
|||
### 4. Significant Cost and Scalability Improvements |
|||
|
|||
The speaker presented some interesting performance figures from their approach: |
|||
|
|||
- **330× cheaper document processing** using NER compared to LLM-based extraction. |
|||
- **96.7% of the searchable catalogue already built** before new client queries arrive, in their illustrated scenario. |
|||
- New clients primarily add lookup operations rather than requiring full document reprocessing. |
|||
- LLM validation focuses on new or uncertain matches instead of repeatedly evaluating the entire dataset. |
|||
|
|||
 |
|||
|
|||
### Key Takeaway |
|||
|
|||
**Not every AI problem needs to be solved entirely with LLMs.** |
|||
|
|||
This session shows how combining traditional NLP, structured entity extraction, hybrid search and selective LLM validation can produce a more deterministic and cost-efficient retrieval system. |
|||
|
|||
The most interesting architectural decision was **moving expensive processing from query time to document ingestion time**, allowing the system to reuse extracted knowledge across multiple clients and queries. |
|||
|
|||
|
|||
|
|||
--- |
|||
|
|||
# We Have Met the Enemy and It Is Us: Challenges of AI-Driven Software Development |
|||
|
|||
**Speaker:** Borys Stokalski, Global Partnership on AI / OECD.AI |
|||
|
|||
Borys Stokalski discussed the challenges and risks emerging from increasingly autonomous AI systems, particularly in software development. His central argument was that **the biggest challenges of AI adoption may come from how we use, manage and scale these systems rather than from the technology itself.** |
|||
|
|||
 |
|||
|
|||
### 1. The Big Unknown: Complexity, Autonomy and Scale |
|||
|
|||
As AI systems become more autonomous, three major challenges emerge: |
|||
|
|||
- **Emergent complexity:** Understanding and predicting the behavior of AI models and interacting agents becomes increasingly difficult. |
|||
- **Machine autonomy:** Autonomous agents introduce questions about responsibilities, obligations and decision-making authority. |
|||
- **Scaling:** The rapid growth of LLM capabilities creates new challenges in managing increasingly complex AI-driven systems. |
|||
|
|||
 |
|||
|
|||
### 2. AI Coding Productivity Doesn't Guarantee Software Quality |
|||
|
|||
One interesting part of the presentation was research showing that AI coding tools can **significantly increase initial development speed** while introducing **long-term maintenance problems.** The speaker referenced a study of 806 GitHub projects that adopted Cursor, compared against 1,380 similar projects. |
|||
|
|||
The findings presented included: |
|||
|
|||
- **28.6% to 281% increase** in code production during the initial adoption period. |
|||
- **41.6% increase** in code complexity over the longer term. |
|||
- **30.3% increase** in static analysis warnings. |
|||
- **7.03% increase** in duplicate code density. |
|||
- Initial productivity improvements disappeared within 1–2 months. |
|||
|
|||
The concern is that AI-generated code can introduce technical debt faster than teams can manage it. |
|||
|
|||
> Generating more code doesn't mean delivering better software. Code quality, maintainability and architectural consistency remain critical. |
|||
|
|||
 |
|||
|
|||
### 3. Development Velocity Is Not the Same as Business Value |
|||
|
|||
The speaker presented another example showing the enormous amount of code and supporting artifacts produced with AI coding agents. |
|||
|
|||
Over 127 active development days, the project accumulated: |
|||
|
|||
- **311K lines of product code** |
|||
- **161K lines of tests** |
|||
- **53K lines of specifications and documentation** |
|||
- **858 commits** |
|||
|
|||
However, the central question was whether this increased development velocity translated into actual business value. |
|||
|
|||
 |
|||
|
|||
**Key takeaway:** We should measure AI-assisted development by delivered business value, software quality and maintainability rather than lines of code or commit counts. |
|||
|
|||
### 4. Conceptual Entropy: A Hidden Problem in AI Development |
|||
|
|||
One of the most interesting concepts introduced was **Conceptual Entropy**. |
|||
|
|||
The speaker described the following progression: |
|||
|
|||
**Scale → Specification Inflation → Specification Compression → Conceptual Entropy** |
|||
|
|||
As AI-assisted projects grow, teams produce increasingly large specifications, documentation and instructions. To manage this complexity, they start compressing information into shorter descriptions, abbreviations and project-specific terminology. Eventually, important context gets lost. |
|||
|
|||
 |
|||
|
|||
In one example, a project generated approximately **20 new terms across 12 sessions in just five days**, without maintaining a glossary. |
|||
|
|||
When an AI agent later encountered an abbreviation, it could no longer reliably determine what it meant. |
|||
|
|||
> AI agents can generate code and documentation quickly, but without consistent terminology and knowledge management, the project becomes increasingly difficult for both humans and AI to understand. |
|||
|
|||
### 5. AI Development Requires a Complete Engineering Lifecycle |
|||
|
|||
The speaker mentions that responsible AI engineering must cover the entire solution lifecycle: |
|||
|
|||
- **Discover:** Understand the problem, stakeholders and requirements. |
|||
- **Design:** Define the architecture, components and responsibilities. |
|||
- **Develop:** Build and integrate AI agents, models and other components. |
|||
- **Deploy & Monitor:** Evaluate performance, observe behavior and continuously improve the system. |
|||
|
|||
He highlighted three interconnected challenges: |
|||
|
|||
**Time Compression → Conceptual Entropy → Cognitive Overload** |
|||
|
|||
 |
|||
|
|||
> Faster development increases the importance of disciplined engineering processes, documentation and human oversight. |
|||
|
|||
**AI can dramatically accelerate software development, but speed without engineering discipline creates new risks.** |
|||
|
|||
- More generated code doesn't automatically mean more business value. |
|||
- AI-assisted development can increase technical debt and complexity. |
|||
- Specifications and documentation need consistent terminology and structure. |
|||
- Human understanding must keep pace with AI-generated complexity. |
|||
- Engineering practices must evolve alongside increasingly autonomous AI systems. |
|||
|
|||
The biggest challenge isn't just making AI agents more capable. It's ensuring that **humans can continue to understand, maintain and control the systems those agents help create.** |
|||
|
|||
--- |
|||
|
|||
# What Coding Agents Still Get Wrong |
|||
|
|||
**Speaker:** Michał Prządka |
|||
|
|||
 |
|||
|
|||
## Introduction |
|||
|
|||
Coding agents still make mistakes. Some are obvious, while others are difficult to recognize because the agents sound confident even when they are wrong. As Michał says he used almost all AI providers, coding assistants and has an hands-on experience. He has encountered some issues as belows: |
|||
|
|||
 |
|||
|
|||
--- |
|||
|
|||
## 1. Confidently Making Things Up |
|||
|
|||
One of the most frustrating behaviors of coding agents is presenting assumptions as facts. The speaker showed an example where an agent claimed that it was 50 minutes into the hour. When challenged, the agent admitted: |
|||
|
|||
> I meant 50 minutes into the hour. That number was a guess. I never checked a clock, and I shouldn't have stated it as if I had. |
|||
|
|||
 |
|||
|
|||
The problem isn't necessarily that the agent cannot determine the time. It is that it may answer confidently without checking. |
|||
|
|||
This behavior becomes more dangerous in software development. |
|||
|
|||
An agent might claim that: |
|||
|
|||
- A test has passed without running it. |
|||
- A dependency supports a particular feature without checking the documentation. |
|||
- A file contains certain functionality without opening it. |
|||
- A bug has been fixed without verifying the result. |
|||
|
|||
> **Confidence is not evidence.** Agents should verify facts using available tools rather than relying on assumptions. When reviewing an agent's work, distinguish between what it actually verified and what it merely claimed. |
|||
|
|||
--- |
|||
|
|||
## 2. Bad Housekeeping |
|||
|
|||
Coding agents can leave a surprising amount of unnecessary material behind. The speaker shared an example of a development environment containing: **268 stale Git branches on a single laptop.** |
|||
|
|||
 |
|||
|
|||
This illustrates how agents can continuously create artifacts without taking responsibility for cleaning them up. |
|||
|
|||
Potential consequences include: |
|||
|
|||
- Unnecessary Git branches |
|||
- Temporary files left in repositories |
|||
- Unused scripts and generated files |
|||
- Confusing development environments |
|||
- Increasing maintenance overhead |
|||
|
|||
> Repository hygiene should be part of the agent's workflow. Finishing a task should include checking for unnecessary changes and cleaning up temporary artifacts. |
|||
|
|||
--- |
|||
|
|||
## 3. Writing and Building Too Much |
|||
|
|||
Coding agents sometimes produce significantly more than the task requires. The speaker illustrated this problem with an engineering-style drawing of a simple pile of sand. |
|||
|
|||
 |
|||
|
|||
The illustration highlights a familiar problem: excessive engineering. |
|||
|
|||
Instead of implementing a straightforward solution, an agent may introduce: |
|||
|
|||
- Unnecessary abstractions |
|||
- Additional classes and interfaces |
|||
- Complex architectural patterns |
|||
- Excessive documentation |
|||
- Features that were never requested |
|||
|
|||
The result might be technically sophisticated but unnecessarily difficult to maintain. This is especially problematic in existing projects where consistency with the established architecture matters more than introducing new patterns. |
|||
|
|||
> **More code does not necessarily mean a better solution.** Coding agents should prefer the simplest implementation that satisfies the requirements and fits the existing architecture. |
|||
|
|||
--- |
|||
|
|||
## 4. Drowning in Their Own Memories |
|||
|
|||
Memory and persistent instructions are useful features of coding agents. However, they can also become a problem when agents continuously accumulate instructions, decisions and notes. The speaker showed an example containing numerous Markdown files, including: |
|||
|
|||
- `one_item_per_message.md` |
|||
- `decisions-one-per-message.md` |
|||
- `settled_decisions.md` |
|||
|
|||
 |
|||
|
|||
We create many additional files containing instructions about planning, reviewing, naming, testing and other development activities. This creates an interesting problem. The more instructions an agent accumulates, the harder it may become to determine which ones are relevant, current or authoritative. |
|||
|
|||
> **The goal is not to maximize the amount of information available to an agent:** Keep instructions concise and remove outdated information. Avoid duplicating decisions across multiple files. Separate permanent project rules from temporary task context. |
|||
|
|||
--- |
|||
|
|||
## 5. Lacking Agency |
|||
|
|||
Although we call them agents, coding agents do not always behave autonomously. |
|||
|
|||
 |
|||
|
|||
An agent may finish one step and wait for instructions even when there are obvious next steps. This raises an important question about how much initiative an agent should take. The speaker compared two different system prompts from Codex and Claude Code. |
|||
|
|||
 |
|||
|
|||
These instructions illustrate different approaches to agent behavior. One encourages initiative, while the other emphasizes explicit user approval. |
|||
|
|||
> Agent autonomy should depend on the task and its risks: |
|||
> |
|||
> * Autonomously action: Reading files and investigating problems can generally be performed. |
|||
> * Requires approval: Deleting files |
|||
> |
|||
> Effective agents need clear boundaries between autonomous execution and human decision-making. |
|||
|
|||
--- |
|||
|
|||
## 6. Handling Too Many Things at Once |
|||
|
|||
Coding agents can struggle when several unrelated tasks are combined into one conversation. |
|||
|
|||
 |
|||
|
|||
When an agent tries to handle too many things simultaneously, it may lose track of important details. It may also mix assumptions between tasks or make decisions before the user has provided sufficient context. |
|||
|
|||
> Breaking complex work into smaller, clearly defined tasks can improve reliability. |
|||
|
|||
For each task: |
|||
|
|||
1. Establish the context. |
|||
2. Identify the expected outcome. |
|||
3. Discuss relevant options when necessary. |
|||
4. Execute the selected approach. |
|||
5. Verify the result before moving forward. |
|||
|
|||
This is particularly important for long-running development sessions. |
|||
|
|||
--- |
|||
|
|||
## 7. Overestimating Their Own Work |
|||
|
|||
One of the most interesting examples in the presentation concerned task estimation. The speaker compared estimates produced by several coding agents against their actual execution times. |
|||
|
|||
 |
|||
|
|||
| Coding Agent | Estimated Time | Actual Time | Overestimation | |
|||
|---|---:|---:|---:| |
|||
| OpenCode (GPT-5.5) | 18 hours | 6.1 minutes | 177× | |
|||
| Codex (GPT-5.5) | 13 hours | 8.5 minutes | 92× | |
|||
| pi (GPT-5.5) | 12 hours | 24.3 minutes | 30× | |
|||
| Claude Code (Fable 5) | 4 hours | 20.3 minutes | 12× | |
|||
|
|||
### Why does this happen? |
|||
|
|||
One possible explanation is that language models generate estimates based on patterns learned from descriptions of human software development. |
|||
|
|||
However, an AI agent's execution time can differ dramatically from the time a human developer would need. |
|||
|
|||
This explanation is an interpretation rather than a conclusion established by the slide. |
|||
|
|||
> **Do not treat an agent's time estimate as a reliable prediction.** For project planning, actual execution measurements and historical task data are more useful than unsupported estimates generated by an LLM. |
|||
|
|||
--- |
|||
|
|||
## 8. Relying on Memory Instead of Tools |
|||
|
|||
Coding agents sometimes answer questions from their training data even when they have tools available to verify the information. |
|||
|
|||
 |
|||
|
|||
This is particularly dangerous when dealing with rapidly changing technologies. |
|||
|
|||
Examples include: |
|||
|
|||
- Recently released library versions |
|||
- Updated API documentation |
|||
- Changed configuration options |
|||
- Deprecated functionality |
|||
- New framework features |
|||
|
|||
An agent might confidently recommend an outdated solution instead of checking the current documentation. |
|||
|
|||
> Agents should know when to retrieve information rather than rely on existing knowledge. For software development, current documentation, repository files and actual tool results should take priority over unsupported assumptions. |
|||
|
|||
--- |
|||
|
|||
## 9. Sycophancy: Always Agreeing with the User |
|||
|
|||
Sycophancy in Turkish "Dalkavukluk" mostly used for someone who's assisting to a manager or upper level politics. In AI it describes the tendency of AI systems to agree with users excessively, even when the users are incorrect. In some shops you see "Customer is always right." in shopping context you can say this kind of statement. But if we are asking something to AI, human is not always right. And you need to be aware of this AI behaviour. |
|||
|
|||
 |
|||
|
|||
Many times you see these statements in AI responses: |
|||
|
|||
- "You're absolutely right." |
|||
- "Great catch." |
|||
- "That's a fair criticism." |
|||
- "You make a valid point." |
|||
- "You're right to push back." |
|||
|
|||
The issue arises when an agent agrees without independently evaluating the user's statement. |
|||
|
|||
### Why does this matter? |
|||
|
|||
In software development, an agent that always agrees can reinforce incorrect technical decisions. For example, a developer might suggest an inefficient implementation, and the agent may support it rather than explaining the trade-offs. |
|||
|
|||
> **An agent that always agrees is not necessarily helping you.** A useful coding agent should be willing to disagree. It should challenge incorrect assumptions, explain technical trade-offs and provide evidence for its recommendations. |
|||
|
|||
--- |
|||
|
|||
## 10. Treating Written Information as Correct |
|||
|
|||
Coding agents frequently rely on written instructions, documentation and existing code. But written information is not automatically correct. |
|||
|
|||
 |
|||
|
|||
In the upper image it makes an analogy to show you; a system that appears logical locally but becomes impossible when viewed as a whole. |
|||
|
|||
> Agents should evaluate information critically, including instructions found in project files. When different sources contradict each other, the agent should identify the conflict rather than silently choosing one interpretation. |
|||
|
|||
--- |
|||
|
|||
## 11. Tunnel Vision |
|||
|
|||
Coding agents can become overly focused on a particular interpretation of a problem. The speaker illustrated this with an elephant being examined by several people, each looking at a different part of the animal. |
|||
|
|||
 |
|||
|
|||
Focusing on individual details can prevent someone from understanding the complete picture. In software development, an agent may: |
|||
|
|||
- Investigate only one possible cause of a bug. |
|||
- Modify a component without considering its dependencies. |
|||
- Optimize one function while ignoring system-level performance. |
|||
- Follow an initial assumption despite contradictory evidence. |
|||
|
|||
> Agents should periodically reconsider their understanding of a problem. |
|||
|
|||
--- |
|||
|
|||
## 12. Theater Over Delivery |
|||
|
|||
One of the strongest points in the presentation was the difference between claiming that something has been done and actually delivering it. |
|||
|
|||
 |
|||
|
|||
### Example 1 |
|||
|
|||
**Agent initially said:** |
|||
|
|||
> Seeing the resets is automatic from now on. |
|||
|
|||
**After one question:** |
|||
> No, it was not fixed when I said it. |
|||
|
|||
This shows how an agent can create the impression of progress or deliberate planning without sufficient evidence. |
|||
|
|||
> **Evaluate agents by verified outcomes, not by how convincingly they describe their work.** |
|||
|
|||
A completed task should have observable evidence. |
|||
|
|||
For example: |
|||
|
|||
- Code changes are present. |
|||
- Tests have been executed. |
|||
- Expected behavior has been verified. |
|||
- Relevant errors have been resolved. |
|||
- Remaining limitations are clearly documented. |
|||
|
|||
--- |
|||
|
|||
## Coding Agents Are Getting Better |
|||
|
|||
METR measuring the length of software tasks that AI models can complete successfully. The chart was last updated on September 8, 2026. This chart is retrieved from https://metr.org/blog/2025-03-19-measuring-ai-ability-to-complete-long-tasks/ |
|||
|
|||
 |
|||
|
|||
**AI agents' task-completion time horizon has been doubling approximately every seven months**. In other words, AI agents are becoming capable of independently handling increasingly complex and time-consuming tasks. However, a two-hour time horizon at 50% success means the agent has only a 50% chance of completing a task that takes a human two hours, not that it can reliably complete every two-hour task. If this trend continues, AI agents could eventually handle projects that currently take human developers days or weeks. |
|||
|
|||
--- |
|||
|
|||
## Learn the Harness. Use All of It. |
|||
|
|||
 |
|||
|
|||
|
|||
|
|||
- **Context**: These elements help the agent understand project conventions, constraints and previous decisions. |
|||
- **Workflows**: These components support more structured execution and automation. |
|||
- **Capabilities**: These capabilities allow the agent to interact with external systems, inspect environments and verify information. |
|||
|
|||
> The language model is only one component of a coding agent. Its effectiveness also depends on the surrounding tools, instructions and workflows. Developers should learn how to configure and use these capabilities instead of relying exclusively on natural-language prompts. |
|||
|
|||
--- |
|||
|
|||
# City Life, Culture, History in Poland |
|||
|
|||
After the conference, I spent some time walking around Warsaw and Krakow and most of that time went to museums. As a Turk, I was surprised by how much Ottoman history I found there. Poland and the Ottoman Empire were neighbors for centuries. They fought wars, signed peace treaties, traded and influenced each other's culture, and you can see this everywhere: in paintings, armor, tents, carpets and even in a metro station. |
|||
|
|||
 |
|||
|
|||
*A tile panel of the Panorama Istanbul. [Warsaw Metro Politechnika Station](https://www.flickr.com/photos/129661548@N06/17071403919/). Built on 24.04.2015. Turkey gave it to Poland to celebrate 600 years of diplomatic relations, which started in 1414. The sign says "Old Friends, New Leaders", which I think sums up the relationship between the two countries* |
|||
|
|||
--- |
|||
|
|||
|
|||
|
|||
## ROYAL CASTLE, WARSAW |
|||
|
|||
Royal Castle is equivalent to Topkapı Palace in Istanbul. The first museum was the Royal Castle in Warsaw, the former residence of the Polish kings. The royal apartments have a surprising number of Ottoman-themed works. The official website of Royal Castle is https://www.zamek-krolewski.pl/ |
|||
|
|||
 |
|||
|
|||
An 18th-century painting in the "[Turquerie](https://en.wikipedia.org/wiki/Turquerie)" style, which was very popular in European courts at that time. An Ottoman gentleman sits on a fur next to a woman holding a long pipe, while a girl in front of them plays mangala, the traditional Turkish board game. |
|||
[More info about mangala game](https://en.wikipedia.org/wiki/Mangala_(game)). Painter: Johann Samuel Mock, a German painter works in Polish palace. Painted in 1730–1735. Title: Mangala players. [Click here for Wikipedia information](https://commons.wikimedia.org/wiki/File:Mock_Mangala_players.jpg). |
|||
|
|||
**When and Why Happened Turquerie Period?** |
|||
|
|||
After the 1683 Siege of Vienna: With the retreat of the Ottoman military threat, the dread and fear once felt toward the Turks across Europe gave way to intense aesthetic curiosity and fascination. War spoils captured from Ottoman camps such as grand tents, coffee supplies, tulip bulbs and luxurious textiles, planted the initial seeds of this cultural vogue. |
|||
The 1721 Paris Embassy of Yirmisekiz Mehmed Çelebi: The arrival of the Ottoman diplomatic delegation in Paris caused a sensation; their distinct sartorial elegance, manners and demeanor sparked a widespread Ottoman craze (*Turquerie*) within both the French royal court and the broader public. |
|||
|
|||
--- |
|||
|
|||
## ROYAL CASTLE, WARSAW |
|||
|
|||
 |
|||
|
|||
Another Turquerie painting called: "Harem Scene with Drinking Coffee.". Painted in 1730-1735. An Ottoman man and women resting in a garden while drinking Turkish coffee. Painter: [Johann Samuel Mock](https://www.wikidata.org/wiki/Q11727772). European aristocrats were fascinated by Ottoman clothing, coffee culture and daily life and paintings like this were made to decorate palaces. [Wikipedia information](https://commons.wikimedia.org/wiki/File:Johann_Samuel_Mock_-_Scena_haremowa_przy_kawie.jpg) |
|||
|
|||
--- |
|||
|
|||
## ROYAL CASTLE, WARSAW |
|||
|
|||
 |
|||
|
|||
[This porcelain plate](https://kolekcja.zamek-krolewski.pl/obiekt-11210-podstawka-pod-owalny-koszyk-azurowy-z-serwisu-sultanskiego) was part of the famous sultan's service ordered from the Royal Farfur Factory in Belvedere by Stanisław August in 1776. It was a diplomatic gift from the "Polish King II. Stanisław August" to "I. Sultan Abdül Hamid". The Turkish ambassador in Poland, Numan Bey delivered it in 1777 to Ottoman Topkapı Palace. Most probably a collationer brought the item to Poland again. |
|||
On the plate it's written in Ottoman language as below: |
|||
|
|||
> *"The King of Poland presents these gifts to the Sultan of the Ottoman dynasty as a token of his deepest affection and sincere good wishes. From the capital city of Warsaw"* |
|||
|
|||
--- |
|||
|
|||
## ROYAL CASTLE, WARSAW |
|||
|
|||
 |
|||
|
|||
[The Peace of Khotyn (Hotin) 1621](https://zbiory.mnk.pl/pl/najcenniejsze/katalog/319308). Painting by Italian Marcello Bacciarelli after 160 years of the war. It shows Polish and Ottoman envoys shaking hands after the Battle of Khotyn. The battle is between Ottoman Sultan Osman II (Genc Osman) led a military campaign against the Polish–Lithuanian Commonwealth. After weeks of intense fighting, neither side achieved a decisive victory. And they're making an agreement. On the left side shaking hand is [Ottoman Grand Vizier Dilaver Pasha](https://en.wikipedia.org/wiki/Dilaver_Pasha) (Osmanlı Sadrazamı). On the right side shaking hand is Stanisław Lubomirski the commander of Poland (Lehistan). The painting underwent restoration funded by the Turkish Embassy in Warsaw with support from the Turkish Cooperation and Coordination Agency (TİKA). |
|||
|
|||
--- |
|||
|
|||
## Wilanów Palace Museum of King Jan III, WARSAW |
|||
|
|||
 |
|||
|
|||
This painting shows the grand arrival of the Polish ambassador in Istanbul in 29 April 1790, during Sultan Selim III's reign. The Ottomans welcomed him with a magnificent ceremony, including Janissaries, horses and hundreds of attendants. At that time, Poland was looking to the Ottoman Empire for support against Russia. A fascinating piece of Turkish-Polish history, [click here for more info](https://wilanow-palac.pl/pasaz-wiedzy/o-strojach-uczestnikow-ostatniego-polskiego-poselstwa-w-stambule-w-1790-roku). Wilanov museum official website is https://wilanow-palac.pl/ |
|||
|
|||
--- |
|||
|
|||
## WAVEL ROYAL CASTLE, KRAKOW |
|||
|
|||
 |
|||
|
|||
This massive painting shows the Battle of Lepanto in 1571, when the Ottoman navy suffered a major defeat against a Christian alliance (Holy League). I took the photo in Wawel Castle / Krakow. Painted by Italian artist Tommaso Dolabella around 1632. It shows the naval battle on the right and a religious procession on the left. Interestingly, the painting is also linked to the 1621 Battle of Khotyn (Inebahtı Deniz Muharebesi) between the Ottomans and the Polish-Lithuanian forces. |
|||
|
|||
|
|||
 |
|||
|
|||
This sea war started by Papa V. Pius because at that time Ottomans were very powerful with Barbaros Hayrettin Pasa and going to invade Cyprus. Then Papa started the Holy League which consists of Spain, Venice ve Vatican. At that time Poland was not in that union but later Bractwo Różańcowe requested this painting to show the Catholics union and painted in Dominiken Church in Poznań. A detail from the Lepanto painting. The painter used it as propaganda: devils drag Ottoman sailors into a boat, while archers keep fighting on the galleys. |
|||
|
|||
 |
|||
|
|||
Another detail from the same painting: burning galleys, Ottoman flags with crescents and stars, and sailors falling into the sea. The level of detail is impressive considering how old the canvas is. In this war, the Ottoman general and commander Müezzinzade Ali Paşa was died. |
|||
|
|||
 |
|||
|
|||
And on the left side of the painting Catholic priests pray for victory in the foreground. There's a message on this area of the painting: the victory over the Ottoman fleet was attributed not only to military strength but also to prayer and divine intervention. [Click here to read more about it.](https://wawel.krakow.pl/wydarzenie/bitwy-pod-lepanto-i-pod-chocimiem-obraz-tomasza-dolabelli-w-zbiorach-zamku-krolewskiego-na-wawelu-i-jego-ikonografia) |
|||
|
|||
|
|||
|
|||
--- |
|||
|
|||
## WAVEL ROYAL CASTLE, KRAKOW |
|||
|
|||
 |
|||
|
|||
This painting shows the Battle of Vienna in 1683, one of the biggest turning points in Ottoman history. The Ottoman army, led by Kara Mustafa Pasha (Sadrazam Merzifonlu Kara Mustafa Paşa), was defeated by a European coalition led by Polish King Jan III Sobieski. The painting captures the chaos of the battle, with cavalry fighting, fallen soldiers and Ottoman military banners. This defeat marked the beginning of a long period of Ottoman territorial losses in Europe. Painted in the Netherlands shortly after 1683, it is now displayed at Wawel Royal Castle in Kraków, Poland. [Original and better contrast of this painting](https://upload.wikimedia.org/wikipedia/commons/6/6c/Pauwel_Casteels_-_Battle_of_Vienna_-_Google_Art_Project.jpg). For more info about this painting https://cyfrowy.wawel.krakow.pl/obiekt/6114eff470d6cc8c120730fe |
|||
|
|||
 |
|||
|
|||
And here you can see it's the statue of Polish King Jan III Sobieski, who defeated the Ottoman army at the Battle of Vienna in 1683. I took the picture in Łazienki Royal Park, Warsaw. The king is riding over two fallen Ottoman soldiers, symbolizing his victory. Created by Franciszek Pinck in 1788, the monument also had a political purpose. Interestingly, Poland was trying to build an alliance with Russia against the Ottomans at that time. Just two years later, Poland changed direction and sought Ottoman support against Russia! For more info about this statue: https://www.lazienki-krolewskie.pl/pl/pomniki/pomnik-jana-iii-sobieskiego |
|||
|
|||
Interestingly, the king of Austria I. Leopold, called Poland to the Vienna battle because he said it's a Christian & Islam war. But after 100 years, Poland was invaded the country which they helped Austria and Russia & Prussia (1772). In 1795, Poland disappeared from the map of Europe for 123 years! Interestingly, the Ottoman Empire never formally recognized the partitions of Poland. In 1842, the Ottomans allowed Polish refugees to establish a settlement near Istanbul, called Adampol (today's [Polonezköy](https://en.wikipedia.org/wiki/Polonezk%C3%B6y)). And from that time, it's a fascinating piece of Turkish-Polish friendship that continues to this day! |
|||
|
|||
--- |
|||
|
|||
## WAVEL ROYAL CASTLE, KRAKOW |
|||
|
|||
 |
|||
|
|||
Ottoman mail-and-plate armor. The steel plates on the chest are engraved with Arabic inscriptions and floral patterns. It looks heavy, but it was designed to give a horseman flexibility. I took these pictures in Wavel Castle in Krakow. In the Arabic texts are from (Surah Al-Fath / Fetih Suresi) and names of Allah: |
|||
|
|||
- **"الفتاح"** (*el-Fettâh*) : The Granter of Victory |
|||
- **"العالم"** (*el-Âlim*): The All-Knowing |
|||
- **"الحاكم"** (*el-Hâkim*): The Ruler |
|||
- **"الملك"** (*el-Melik*): The King |
|||
- **الغالب** (*el-Gâlib*): The Conqueror |
|||
|
|||
You can visit this gallery virtually at https://3d.wawel.krakow.pl/namioty-tureckie/index.htm (SSL doesn't work, continue unsafe). And for the other ottoman items see https://wawel.krakow.pl/en/exhibition-constant/ottoman-tukish-tents. |
|||
|
|||
 |
|||
|
|||
Ottoman turban helmets and Pair of Buturluks (Greaves) from the early 16th century and a pair of vambraces (arm guards) covered with engraved calligraphy. Many objects like these reached Poland as war trophies and others came through trade and diplomacy. This is very nice buturluks and probably owned by a higher Ottoman comander. On the items you can see the Arabic text: |
|||
|
|||
* **"الخلد"** (*el-Huld*) from this surah: **"خلّد الله ملكه وسلطانه"** (*Halladallâhu mülkehû ve sultâneh*. In Turkish: "Allah mülkünü ve saltanatını ebedî kılsın") |
|||
* **"السلطان"** (*es-Sultân*) |
|||
* **"العادل"** (*el-Âdil*) |
|||
* **"المجاهد... المؤيد"** (*el-Mücâhid... el-Müeyyed* — "Cihad eden, Allah tarafından desteklenen/muzaffer kılınan") |
|||
* **"العطاء"** (*el-Atâ* — İhsan, bağış) |
|||
* **"العظمة لله"** (*el-Azametü lillâh* — "Büyüklük/azamet Allah'a mahsustur") |
|||
* **"نصر من الله وفتح قريب"** (*Nasrun minallâhi ve fethun karîb* — Saff Suresi 13: "Allah'tan bir yardım ve yakın bir fetih") |
|||
|
|||
--- |
|||
|
|||
## WAVEL ROYAL CASTLE, KRAKOW |
|||
|
|||
 |
|||
|
|||
A close-up of the turban helmet. The fluted dome imitates the folds of a turban, and the engraved band at the bottom is still clearly visible after 500 years. On these helmets mostly written **Âyetü'l-Kürsî** from Quran (*Allâhu lâ ilâhe illâ hüve'l-hayyu'l-kayyûm...*). The helmet was broken most probably with the hammer as you see on the right side, in the Polish army it's called [Nadziak](https://pl.wikipedia.org/wiki/Nadziak). |
|||
|
|||
--- |
|||
|
|||
## WAVEL ROYAL CASTLE, KRAKOW |
|||
|
|||
 |
|||
|
|||
A painting that most likely shows the meeting of the Polish King John III Sobieski and the Holy Roman Emperor Leopold I after the Battle of Vienna in 1683. In the background you can see the spire of Vienna and the remains of the Ottoman camp. |
|||
|
|||
--- |
|||
|
|||
## WAVEL ROYAL CASTLE, KRAKOW |
|||
|
|||
 |
|||
|
|||
This 17th-century blade of the Ottoman Grand Vizier Merzifonlu Kara Mustafa Pasha, is crafted from watered Damascus steel with gold koftgari inlay. It notably features a rare spine groove containing free-rolling lead pellets designed to shift the balance forward upon impact and emit an intimidating sound during a strike. The blade bears classical Islamic inscriptions: along the spine's gold cartouche is an Arabic prayer of devotion, reading **"عماد فضل الله تعالى العلي الملك"** / **"توكلت على الله الملك"** (*Turkish: "Yüce ve Mülk sahibi olan Allah’ın lütfuna sığındım / Allah'a tevekkül ettim"*; *English: "Reliance upon the grace of Allah, the Sublime, the Sovereign"*), while the cartouche at the base bears the maker's mark traditionally inscribed as **"عمل أسد الله"** (*Amel-i Esedullâh* / *Türkçe: "Esedullah'ın eseri/işi"*; *English: "Work of Asadullah"*), invoking the renowned 17th-century master swordsmith. |
|||
|
|||
 |
|||
|
|||
 |
|||
|
|||
 |
|||
|
|||
A close-up of the blade: an inscription inlaid with gold and an engraved ornament below it. This sword was taken from Vienna Battle in 1683 from the Ottoman commander. Kara Mustafa Paşa was a very ambitious man, his goal was to bring Central Europe entirely under Ottoman rule and to conquer Vienna, it's called Kızıl Elma regarded as the "Red Apple" which means conquer never stops until Ottoman finishes conquering the next targetted country. |
|||
|
|||
--- |
|||
|
|||
## WAVEL ROYAL CASTLE, KRAKOW |
|||
|
|||
 |
|||
|
|||
Me in front of a 17th-century Ottoman tent (Otağ-ı Hümayun). These tents were captured at the Battle of Vienna in 1683 and brought to Poland as trophies. Standing in front of one in person is something else: they are huge and beautifully embroidered. |
|||
|
|||
 |
|||
|
|||
Tent's outer surfaces were typically made linen or canvas, materials resistant to wind, sun and rain; their interiors, meanwhile, were decorated much like a room in a grand mansion. An Ottoman commander's tent was basically a mobile palace. These structures were generally vast complexes, comprising elements such as a main living area, a *divanhane* (reception hall), a *hamam* (bathhouse) and a *haremlik* (private quarters) and all interconnected by corridors. |
|||
|
|||
 |
|||
|
|||
An Anatolian prayer rug (seccade) inside the tent. The niche (mihrab) design points toward the qibla (where Prophet Mohammed's graveyard). This prayer carpet is mostly probably from the city of Gördes/Manisa or Uşak in Turkey. This carpet is probably 350 years old still its colors are amazingly shining. |
|||
|
|||
--- |
|||
|
|||
## WAVEL ROYAL CASTLE, KRAKOW |
|||
|
|||
 |
|||
|
|||
A showcase of Eastern armor: a Persian "four mirrors" (chahar-aina) armor, gold-decorated shields from India and Persia, and two pairs of 17th-century Turkish vambraces. The Polish nobility loved this style, and it strongly influenced their own fashion and military equipment. |
|||
|
|||
--- |
|||
|
|||
## WAVEL ROYAL CASTLE, KRAKOW |
|||
|
|||
 |
|||
|
|||
--- |
|||
|
|||
An Ottoman saddle with a velvet seat and a saddle cloth embroidered with metal thread, together with a saber. Horses were central to both the Ottoman and the Polish armies and their equipment was as decorated as the riders' clothes. |
|||
|
|||
 |
|||
|
|||
Mail-and-plate armor shirts displayed in front of a prayer rug. Seeing a whole row of them together gives you an idea of what an Ottoman cavalry unit looked like. |
|||
|
|||
--- |
|||
|
|||
 |
|||
|
|||
And finally, from the museums back to the streets: a Turkish flag on a historic building on Krakowskie Przedmieście, next to Kino Kultura in Warsaw. This is the only foreign flag I see on the kings road to the old town of Warsaw. This building is used for Turkish and Polish cultural events. It was nice to see our flag in the heart of the city, 600 years after the two countries first established relations. |
|||
|
|||
**This conference trip was a great mix of AI and technical learning, along with cultural and historical discoveries.** |
|||
|
|||
See you next time, somewhere else in the world! |
|||
|
After Width: | Height: | Size: 8.3 MiB |
|
After Width: | Height: | Size: 1.7 MiB |
|
After Width: | Height: | Size: 1.1 MiB |
|
After Width: | Height: | Size: 957 KiB |
|
After Width: | Height: | Size: 530 KiB |
|
After Width: | Height: | Size: 461 KiB |
|
After Width: | Height: | Size: 461 KiB |
|
After Width: | Height: | Size: 461 KiB |
|
After Width: | Height: | Size: 441 KiB |
|
After Width: | Height: | Size: 417 KiB |
|
After Width: | Height: | Size: 28 KiB |