Introduction

The shift toward autonomous, agentic systems is redefining software engineering. Inspired by how Jon Hyman, co-founder and CTO of Braze, reorganized his engineering organization in just a few months, this guide lays out a proven path for transforming a traditional engineering team into an AI-first powerhouse. Whether you're leading a startup or a legacy enterprise, these steps will help you rethink workflows, architecture, and culture to thrive in the agentic era.

What You Need

• Executive buy-in — a clear mandate from leadership to pivot toward AI-first principles
• Cross-functional champions — engineers, product managers, and data scientists willing to drive change
• Modern tech stack — cloud infrastructure, CI/CD pipelines, and containerization (e.g., Kubernetes)
• Data foundation — clean, accessible datasets and a robust data pipeline (e.g., streaming platforms, data lakes)
• Agentic frameworks — familiarity with orchestration tools like LangChain, AutoGPT, or custom agent architectures
• Learning budget — time and resources for upskilling teams (courses, workshops, hackathons)
• Iteration infrastructure — A/B testing environments, observability stacks (e.g., Datadog, Prometheus)

Step-by-Step Guide

Step 1: Audit Your Current Engineering Culture

Before you can shift to an AI-first mindset, you need a clear picture of where you stand. Conduct a cultural audit by interviewing team leads, reviewing past project cycles, and identifying bottlenecks in decision-making. Ask: How much autonomy do teams have? Are we comfortable with probabilistic outcomes? At Braze, Hyman noted that moving fast required embracing ambiguity and reducing handoffs. Document your findings in a shared charter that everyone can refer to later.

Step 2: Define Your AI-First Vision and Principles

Articulate a concise vision statement — for example, “We build systems that learn, adapt, and act on behalf of users with minimal human intervention.” Then create three to five operational principles that guide your transformation. Examples: “Every team will have at least one AI-powered component in their roadmap within the next quarter.” or “All new features must be designed for continuous learning.” Share these with the whole company through an internal memo and a town hall meeting.

Step 3: Restructure Teams for Agentic Ownership

Traditional siloed teams (backend, frontend, data) slow down agentic development. Instead, create small, cross-functional squads that own end-to-end agent behaviors. Each squad should include a machine learning engineer, a software engineer, a product manager, and a domain expert. Braze reorganized its teams to focus on customer-facing AI agents that could autonomously optimize marketing campaigns. Assign each squad a specific agent capability (e.g., “personalization agent” or “anomaly detection agent”) and give them full autonomy over design, training, and deployment.

Step 4: Implement a Unified Data & Model Pipeline

Agentic systems rely on real-time data and models that learn continuously. Set up a streaming data pipeline (using tools like Apache Kafka or AWS Kinesis) to feed events to a feature store. Then build a model registry (e.g., MLflow) where each squad can version, test, and promote models. Braze invested in a data platform that unified customer data across channels, allowing agents to make decisions with fresh signals. Ensure your pipeline supports both batch and streaming modes to handle various latency requirements.

Step 5: Adopt an Agentic Architecture Pattern

Move from monolithic or microservice architectures to a layered agentic pattern. A common approach is the orchestrator-agent model: a central orchestrator routes user requests to specialized agents, which execute tasks and report back. Use event-driven communication (e.g., message queues) to keep agents loosely coupled. For example, Braze’s AI agents listen to customer engagement events, decide when to send push notifications, and adjust their behavior based on outcome feedback. Provide your squads reference architectures and code templates to speed up adoption.

Step 6: Run a Rapid Pilot with One Agent

Choose a low-risk but high-visibility use case — like an internal customer support triage agent or a content recommendation widget. Limit the pilot to two weeks. During this time, the squad should: define success metrics (e.g., response accuracy, user engagement), train an initial model on historical data, deploy it with guardrails (e.g., human-in-the-loop fallback), and collect telemetry. Braze ran a similar pilot for an AI-powered onboarding agent, which achieved a 30% reduction in drop-offs within 10 days. Document the lessons learned and share them company-wide.

Step 7: Uplevel Your Engineering Team

Not every engineer needs to become a deep-learning expert, but everyone should understand agentic design patterns and prompt engineering. Host weekly brown-bag sessions on topics like “chain-of-thought reasoning” and “reinforcement learning from human feedback (RLHF).” Pair engineers with data scientists in a “buddy system” to cross-train. Braze used a combination of internal hackathons and external courses to upskill 80% of its engineering team in five months. Also, hire a few specialists in MLOps and agent orchestration to accelerate the learning curve.

Step 8: Establish Feedback Loops for Continuous Improvement

Agents need to learn from every interaction. Implement logging for all agent decisions, outcomes, and user feedback. Create a centralized dashboard that shows agent performance per squad, including metrics like task completion rate, latency, and drift alerts. Schedule biweekly review sessions where squads present what their agent learned and how they adjusted the model. Braze built a feedback pipeline that allowed their personalization agents to automatically retrain nightly, leading to a steady 15% lift in campaign performance month over month.

Step 9: Scale by Standardizing Agent Services

Once your pilot succeeds, scale by creating shared services for common agent needs — like a LLM gateway that handles rate limiting and caching, or a safety filter that prevents harmful outputs. Build a marketplace where teams can discover and reuse agent components. Braze created an internal “agent registry” where engineers could publish their agent APIs, documentation, and training datasets. This reduced duplication and accelerated new agent development by 40%. Standardize on a single orchestration framework (e.g., LangGraph or a custom solution) to keep interoperability high.

Step 10: Measure Success Beyond Traditional Metrics

Replace pure output metrics (features shipped, lines of code) with outcome-based measures: agent autonomy rate (percentage of tasks completed without human intervention), learning speed (time from deployment to performance plateau), and user satisfaction scores. Braze tracked these alongside more traditional engineering metrics like uptime and response times. Publish a monthly “AI-First Scorecard” that shows progress across all teams. Use this data to celebrate wins and realign struggling squads.

Tips for a Smooth Transformation

• Start small, learn fast. Don’t try to transform every team at once. Pick one squad and one agent — success breeds buy-in.
• Embrace the learning curve. Agentic development is different from deterministic coding. Expect failures and treat them as data for your next iteration.
• Guard against “black box” fear. Invest in explainability tools (e.g., SHAP, LIME) so that both engineers and product managers can trust agent decisions.
• Keep humans in the loop for critical decisions. Even the most advanced agents need fallback mechanisms for compliance, safety, and edge cases.
• Communicate constantly. Use internal newsletters, Slack channels, and demos to share progress and reduce resistance. Braze’s Hyman held monthly all-hands updates on agentic initiatives.
• Don’t overlook infrastructure costs. Agents can consume significant compute and API credits. Set up cost monitoring and implement budget alerts early.
• Celebrate agent wins. Recognize when an agent autonomously solves a user problem — it reinforces the cultural shift toward AI-first thinking.

By following these steps and adapting them to your organization’s context, you can replicate Braze’s success and lead your engineering team into the agentic era with confidence.