Ercan Er

Co-founder @ironbee_ai | Ex-@Catchpoint, Ex-@thundra (both acquired)

[Ercan Er @Dev_ErcanEr]

@GunlukYZ @serkan_ozal @ironbee_ai Aslında burada token ile ilgili bir ironi yapıldı. Serkan’ın yazdığı kısım gözden kaçmış olabilir. Kendisi, “Şaka yapıyorum tabii 😀, öyle bir token compression yok.” diyerek bunun bir şaka olduğunu zaten belirtmişti.

[Serkan Özal @serkan_ozal]

IronBee güncellenmiş web sayfamız yayında: https://t.co/uQSxeYGbn0

Eğer AI coding agent ların "🚀 I'm done" dedikten sonra kodun hala çalışmamasından bıktıysanız @ironbee_ai'ı denemenizi öneririm.

@Dev_ErcanEr bunu sadece ama sadece 8 token harcayarak yaptı. Şuan artakalan token lar ile insanlık için başka ne yapabilirim diye düşünüyor (Umarım bunu nasıl yaptınız, ne kullandınız gibi sorular gelmez. Şaka yapıyorum tabi 😀, öyle bir token compression yok)

[Serkan Özal @serkan_ozal]

Excited to share that @ironbee_ai has raised its pre-seed round led by @ScaleXVentures.

It’s also great to be partnering with @DilekDayinlarli and the ScaleX Ventures team again. Their conviction, support, and understanding of developer tools made them a natural partner for this journey.

At IronBee, we believe AI coding agents will become a fundamental part of software development. The challenge is no longer generating code, but it’s knowing whether that code is actually correct, safe, and ready to ship.

Our mission is to make AI coding agents trustworthy by autonomously verifying, analyzing, debugging, and fixing the code they produce.

We’re still at the beginning, but we’re excited about what’s ahead and grateful to everyone who has supported us so far.

Onward 🚀

[Serkan Özal @serkan_ozal]

Yes, I have some crazy and radical ideas for @ironbee_ai, and I like to try unusual/crazy things, but, @OpenAI Codex, isn't it a bit much to consider this a cybersecurity risk? 😀

[Ercan Er @Dev_ErcanEr]

For AI agents, observability is no longer a luxury; it is a necessity. Making an agent’s decision making process, tool usage, failure points, and impact on user experience visible is essential for improving performance, controlling costs, and building reliable systems. If you can measure it, you can optimize it.

[Serkan Özal @serkan_ozal]

Ever hit your AI coding agent's context limit and had no idea why?

We've all been there — your agent runs out of context or your bill creeps up, and all you can do is complain. The real problem? You can't see where your context and tokens are actually going.

So we built something new in IronBee: a real-time breakdown of an AI coding agent's active context — down to individual MCP servers, tools, skills, rules, and sub-agents. As far as we know, no other product does this at this granularity.

And it's harder than it looks. Just measuring each tool's tokens in isolation misses the real story:
- Tool definitions consume static context every turn, used or not.
- Tool results become chat history — re-sent to the LLM on every turn.
- Each turn, all this static + dynamic content travels to the API as accumulated history.

You can't optimize what you can't measure at this resolution. @ironbee_ai gives you that visibility — plus concrete optimization recommendations to run your agents more effectively and at lower cost.

Our background in observability and instrumentation is exactly what made this possible. Treating an AI agent's context as a system you can profile changes everything.

Tired of guessing where your tokens go? This one's for you. 👇

[Serkan Özal @serkan_ozal]

IronBee: Session Insights

Your team uses AI coding agents every day. But do you really know what happens inside all those sessions?

@ironbee_ai Session Insights gives you one clear view across your whole account, no log reading needed. You just look, and you understand.

In a single page you can see:
- Sessions, active time, and user messages
- Which tools run mmost, and where errors come from
- Which AI models your team uses
- Top languages and the "hot files" that change the most
- How people use MCP, sub-agents, and skills
- Code added and removed — project by project

For example, in this view (last 30 days):
- 973 sessions
- 1.3K hours of active work
- 15,568 user messages
- +65,664 net lines of code
- 570 tool errors — caught and grouped by type

Less guessing. More clarity. Better decisions for teams building with AI.

[Ercan Er @Dev_ErcanEr]

@serkan_ozal 🚀

[Serkan Özal @serkan_ozal]

💸 How much is your AI coding agent actually costing your organization?

As teams across an org adopt Claude Code & AI agents, the spend scatters — across departments, projects, models, and users. Most organizations have no idea where it really goes.

So we built the Cost analytics view in IronBee 👇

One screen gives the whole organization the answers that used to be impossible:
- Total spend & token usage at a glance — input, output, and cache
- Cost broken down by model, by user, and by project across the org
- Cost over time + cost-per-session-duration trends
- The exact sessions draining your token budget
And because spend you can't trust is spend you can't control, every session is verifiable down to the source.

AI agents are powerful, but they're a black box on the org's invoice. You can't optimize what you can't see.

@ironbee_ai turns that black box into a dashboard.

We're onboarding organizations in private beta — drop a comment or DM if you want early access.

[Serkan Özal @serkan_ozal]

What if you could actually measure how good your AI coding agent is?

That's the question we built @ironbee_ai to answer.

AI agents write code, test it, and fix it, but most teams have no idea what really happens inside those sessions. Did the agent get it right the first time? How often does a "fixed" bug come back? Which files keep breaking?

IronBee's Quality view turns every agent session into simple numbers. Here's a real look at one project (142 sessions analyzed):

✅ First-pass successs: 62% (up 16% vs last week)
🔁 Re-fail rate: 18% (how often a fixed problem comes back)
🔍 Verifications per session: 2.6 (the agent checks its own work)
🐛 Issues caught before calling a task "done": 3.6
⏱️ Only ~69% of time goes to real work (the rest is fixing)

A few things I love:
• Before vs after fix → 4.32 → 2.80. You can literally see fixes making the code better.
• Hot files. It points to the files that break the most (index.css failed 50% of the time).
• The sweet spot. Sessions that run 30–60 min with 4–7 steps pass 78% of the time. Now we know what a healthy session looks like.
• Top blockers. The exact reasons the agent got stuck, ranked.

The big idea is simple: you can't improve what you can't see. IronBee makes agent work visible, so you can trust your agents and make them better. 👇

[Ercan Er @Dev_ErcanEr]

The first part of the IronBee product video series is live.

With IronBee, we are building an autonomous verification and intelligence layer for AI-generated code. Fully replayable runs, timelines, traces, diffs, browser sessions, and proof-backed verifications.

Built with @Remotion , which made creating this product video much smoother.

We would love feedback from teams using AI agents.

Waitlist: https://t.co/OCjqBQEVUR

#IronBee #Remotion #AIAgents #CodingAgents #AICoding #AIEngineering #DevTools #DeveloperTools #SoftwareTesting #CodeVerification #AgenticAI #TestAutomation

[Serkan Özal @serkan_ozal]

Here is first part of the @ironbee_ai product video series (Thanks @Dev_ErcanEr for the video).

AI writes more code than ever. But verifying AI-generated code is still manual, fragmented, and slow.

We are building IronBee. An autonomous verification and intelligence layer for AI coding agents.

IronBee tests, verifies, analyzes, debugs, and fixes AI-generated code while recording every step end to end. Every tool call. Every browser interaction. Every verification flow. Fully replayable.

Here is what you can do with IronBee:
- See it. Every run on one timeline.
- Spot it. Verdict at a glance when something breaks.
- Fix it. The diff right next to the failed span.
- Replay it. Click any tool call, the browser jumps to that moment.
- Watch it. Scrub through the recorded session like a movie.
- Track it. Every step and every screenshot captured.
- Prove it. Verifications with proof.

Early access is opening very soon.

If this resonates with you, hop on the waitlist at https://t.co/uQSxeYGbn0

Would love feedback from anyone shipping with agents in production.

[Ercan Er @Dev_ErcanEr]

Unity just dropped a game changer 👾

[Unity for Games @unitygames]

Unity AI is now in Open Beta 🎉💫

We believe AI has the most impact when it helps creators move faster while staying in control of the creative process.

Use our built-in agent tuned for Unity workflows or connect the AI tools you prefer via AI Gateway and MCP Server.

[Ercan Er @Dev_ErcanEr]

@altugx @elonmusk Qatar Airways ile mi uçtunuz? Starlink Aviation’ın THY de olmadığını biliyorum, o yüzden merak ettim.

[Ercan Er @Dev_ErcanEr]

Building this as @ironbee_ai is incredibly exciting. The future of AI agents isn’t just code generation; it’s understanding real environments, interacting with live products, and solving problems end to end. This is only the beginning

[Serkan Özal @serkan_ozal]

@ironbee_ai's Browser DevTools MCP is now used by developers in 130+ countries.

It gives AI agents direct access to the browser:
seeing the UI, understanding flows, and debugging issues in real time.

If we want AI to move beyond code generation, we need to give it real execution visibility.

That’s the layer we’re building ...

https://t.co/1bsDxx5MW6

[Serkan Özal @serkan_ozal]

@ironbee_ai's Browser DevTools MCP is now used by developers in 130+ countries.

It gives AI agents direct access to the browser:
seeing the UI, understanding flows, and debugging issues in real time.

If we want AI to move beyond code generation, we need to give it real execution visibility.

That’s the layer we’re building ...

https://t.co/1bsDxx5MW6

[Serkan Özal @serkan_ozal]

While building @ironbee_ai's telemetry pipeline for @claudeai Code, to deliver deeper analytics and smarter recommendations for agentic coding sessions, I hit two gaps in the hook and @opentelemetry surfaces that were blocking key insights:

- No "duration_ms" in "PostToolUse" / "PostToolUseFailure" hooks, making it impossible to answer basic questions like "which tool calls took longer than 5 seconds?" without fragile workarounds.
- No "tool_use_id" or "tool_input_size_bytes" in the "claude_code.tool_result" OTel event, blocking clean correlation between hook events and OTel logs, and forcing a privacy trade-off just to learn input sizes.

I opened two feature requests on the Claude Code repo detailing the use cases and proposed solutions, and the @AnthropicAI team shipped both within days. 🙌

Huge thanks to the Claude Code team for being this responsive to ecosystem feedback. These small schema additions unlock fleet-wide dashboards, p95/p99 tool latency tracking, and clean joins between hook and OTel data: exactly what IronBee users need to understand and optimize their AI coding workflows.

If you're building observability on top of Claude Code, it just got a lot easier.
- https://t.co/xprXQXZPTa
- https://t.co/vk0MJIfJDo

[Serkan Özal @serkan_ozal]

Big congrats to the Bindplane team on joining Dynatrace! 👏

As someone building in this space, I find this acquisition deeply validating.

The thesis is clear: as AI becomes central to how we build and operate software, the quality and control of operational data becomes everything. Bindplane understood this early by giving teams a control plane for telemetry before it hits the platform. That's a powerful idea, and Dynatrace clearly agrees.

We're building @ironbee_ai with a complementary but different bet:

What if the AI agent itself could decide what data it needs and go get it?

Today's observability is built on a "collect everything, query later" model. But when AI agents are writing code, deploying it, and then need to debug production issues, that model breaks. You either don't have the right data, or you're drowning in irrelevant signals.

IronBee flips this. Our browser agent and runtime instrumentation let AI coding agents dynamically observe their own impact on production by pulling exactly the app state, logs, traces, and environment data needed for root cause analysis, on demand.

https://t.co/ZArG21calP

[Ercan Er @Dev_ErcanEr]

At @ironbee_ai , we believe AI should go far beyond code generation, evolving into systems that manage the full SDLC from idea to production.
#verification #AI #DevOps #SoftwareEngineering

[Serkan Özal @serkan_ozal]

If AI writes your code, it should also test, verify, debug and fix it.

And eventually deploy it.

That’s the vision behind @ironbee_ai: scaling the entire SDLC from development to production.

[Bora Özkent⎪ABD Borsası & Teknoloji Yatırımları @BoraOzkent]

Dubai ülke ETF'i savaş öncesi zirvesine henüz dönmesiyse de kayıplarını epeyce telafi etti.

Daha da ilginci son bir yılda %18 pozitif getiri sağladı.

Dubai bitti diyen değerli analistlerimizi dinlemek yerine dipten alım yapsaydınız sadece bir ayda %11 kardaydınız.

Biz küçük bir swingle biraz nemalandık.

Diyeceğim o ki dünyayı anlamak istiyorsanız parayı takip edin, işkembeci, tribünlere oynayan ve dibine kadar ideolojiye gömülmüş analistleri değil.

Çünkü para gerçeklere odaklanır, laf salatalarına değil.

[Ercan Er @Dev_ErcanEr]

This makes a lot of sense. Lambda + agents feels like a very natural fit when state is externalized. Curious to see more real-world examples

[Serkan Özal @serkan_ozal]

I’ve been designing an execution environment for agents on @awscloud using the @claudeai Agent SDK as part of what we’re building at @ironbee_ai.

I’m currently evaluating AWS Lambda as the core runtime.

There are still some tricks needed to make Lambda a good fit for agent execution. But being an AWS Serverless Hero and having run many different production workloads on Lambda over the years, it wasn’t too hard to adapt.

What makes it interesting (especially with some of the recent AWS updates over the last year):
- Natural scalability out of the box
- Ephemeral runtime (fits prompt-scoped runs well)
- Native per-invocation isolation, now reinforced with tenant isolation features that provide stronger guarantees for running multi-tenant or untrusted workloads
- Amazon S3 Files for both context injection and session continuity / artifact storage
- Can be extended into durable executions where agent workflows are checkpointed, paused, and resumed across invocations with built-in retries and state management

Using S3 Files as a backing layer for sessions also changes the equation as the 15 minute execution limit becomes much less of a constraint when state and artifacts are externalized.

One thing that surprised me: I haven’t really seen such examples of agents executed this way on Lambda.

Feels like a pretty natural fit.

#Serverless #AWS #AIAgents

[Serkan Özal @serkan_ozal]

Browser DevTools MCP has crossed 100K+ installs on NPM, 10K+ installs on the Cursor marketplace, and now has 500+ daily active users.

This growth shows a clear shift. Developers want AI that understands runtime, not just code.

Most issues appear during execution, in the DOM, network, and async flows. Browser DevTools MCP brings that runtime visibility into AI workflows, helping agents observe real behavior instead of guessing.

It is developed by the @ironbee_ai team and is also a core part of IronBee, a verification and intelligence layer for agentic development.

Verification and debugging should be based on real execution, not assumptions.

Thanks to everyone building with it.

NPM: https://t.co/ti7ZvZd9tI
Cursor Extension: https://t.co/uDVnlmaO9o
Web Site: https://t.co/8lU5eIozQj