Introducing Agent Builder

Everyone’s talking about AI agents. But very few enterprises have agents live in production — solving real problems, at scale. Most tools weren’t built for the complexity of enterprise workflows or the cross-functional collaboration it takes to ship them.

At WRITER, we’ve always built for the enterprise. After deploying over 5,000 agents at companies like Salesforce, Kenvue, and Uber, we’ve seen what it really takes to make agents work at scale — and where traditional software development falls short. So we asked: what if agent development were built from the ground up for how enterprise teams actually operate?

Agent Builder is our answer. It’s the only collaborative workspace purpose-built for enterprise agent development — where business and IT teams build together from day one:

• Business teams prototype agents that reflect how they want to work — instead of waiting in line for someone else to build it.
• IT teams get agents production-ready and built for scale — without the scope creep, constant rework, and maintenance overhead.
• Together, they combine their expertise to build agents that actually work in complex, real-world enterprise environments.

Over the past few months, we’ve partnered with customers in a closed beta to test Agent Builder and uncover exactly where the software development lifecycle breaks down — and what building agents the “right” way truly looks like for enterprises.

Today, we’re opening Agent Builder in public beta, inviting more customers to build and share feedback. At WRITER, we build with you — not just for you — and your input is critical in shaping what comes next.

Why you can’t build agents like software

Agents don’t behave like software — and they can’t be built like it either.

They don’t just execute tasks‌ — they pursue outcomes. They aren’t hardcoded with logic‌ — ‌they respond to real-time context. And most importantly? They adapt. You won’t fully understand how an agent behaves until it’s live, interacting with real users, real data, and real edge cases.

This makes success harder to define. It’s rarely black and white. An agent might technically resolve a support ticket‌ — ‌but did it take five unnecessary detours? Escalate something it shouldn’t have? If it were a teammate, would you say they handled it well?

It also means builders will spend less time writing logic upfront‌ — ‌and more time shaping agentic behavior over time. And the people closest to the workflows and outcomes can’t just weigh in from the sidelines — they need to be hands-on from the start.

This new era of agent development demands new mental models, new roles, and new tools that enable deep collaboration between business and IT — and Agent Builder is built for exactly that.

What’s under the hood

Agent Builder brings teams together in one shared development environment to build agents end to end — from backend logic to frontend experience. Each agent is made up of two components, assembled using a visual editor and a library of drag-and-drop blocks:

• Blueprints map an agent’s business logic and behavior — how it processes input, makes decisions, and drives outcomes. Built using LLM-powered blocks like tool calling and RAG knowledge retrieval, blueprints support everything from simple flows to advanced multi-agent orchestration — powered by Palmyra X5, our enterprise-grade LLM with a 1M-token context window.
  
• Interfaces define how the agent shows up to users — whether it’s a guided experience, interactive dashboard, or embedded chatbot. Built with customizable layouts and reusable UI elements like input fields and buttons, interfaces offer a structured way for users to work with agents.

Blueprints and interfaces can’t be built in silos. They need developers who understand the tech and business teams who understand the outcomes. That’s why collaboration isn’t just a feature in Agent Builder — it’s the foundation:

• Live multiplayer editing: Workshop in real time, letting everyone see updates as they happen. Blocks lock automatically to keep work coordinated and conflict-free.
• Inline annotations: Comment on blocks‌ to ‌ask questions, clarify logic, and keep feedback in context, right where the work happens.
• Invite-based access: Bring in the right collaborators at the right time — ‌from securely storing API keys in the agent’s vault to perfecting the interface.

As teams build more agents, they’ll spend less time reinventing the wheel — and more time reusing what already works. Every agent, blueprint, interface, and block becomes part of your enterprise agentic design system: a shared library of modular components that allows you to build once and reuse everywhere — so each agent is faster to build and easier to maintain than the last.

Business teams don’t just give input — they prototype

More often than not, the people who know the workflow best aren’t the ones building the solution. Business teams write up requirements, hand them off, and wait — only to be brought back in once the build is nearly complete. By then, it’s often too late to fix what got lost in translation.

Agent Builder flips that dynamic. It gives business teams the tools to prototype agents themselves‌ — ‌mapping logic, refining prompts, and designing interfaces grounded in how the work actually gets done. With business teams getting hands-on and driving iteration from day one, feedback loops tighten, costly rework goes down, and builds stay aligned from start to finish.

Here’s how Agent Builder empowers business teams:

• Agent templates: Customize prebuilt agents across use cases, from content lifecycle automation to sales prospecting.
• Prompt-to-blueprint: Simply describe what the agent should do, and generate a working blueprint in seconds.
• No-code prompt interface: Tweak prompts without getting stuck in IT backlogs — iterating in real-time as your workflows evolve.
• Composable agents: Easily extend agents by connecting new data or tools, or chaining multiple agents into end-to-end workflows.

Engineers stay focused on the high-value work

In most orgs, engineering teams are stretched thin — ‌not just writing code, but decoding vague requirements, juggling shifting priorities, and untangling misalignment that surfaces weeks into a build. They’re buried in ticket backlogs, reworking features after late-breaking feedback, and rebuilding the same scaffolding again and again.

With Agent Builder, developers don’t need to start from scratch anymore — they get a working prototype that’s ‌already scoped and validated by the business. By eliminating the guesswork and wasted cycles, they can focus on what needs their technical expertise most: writing custom Python logic, securely integrating systems, and getting agents tested and production-ready.

Here’s how Agent Builder reduces technical overhead:

• Modular system: Start with prebuilt blocks for LLM functionality — or drop into Python when you need custom logic.
• Visual logs and traces: Debug faster with full visibility into agent runs‌ — ‌see inputs, branches, and tool calls at every step.
• Version control and testing: Safely iterate on agents with versions — deploy to a test group before rolling out company-wide.
• Secure secret management Secure systems and tools, managing API credentials in an encrypted vault‌ for each agent.

Get started

The next chapter of enterprise AI won’t be built with legacy tools or siloed teams. Agent Builder is now in public beta — and we’re inviting teams to help shape what comes next.

Ready to take the next step?

• Start building: Get hands-on with Agent Builder by exploring our docs and tutorials.
• Shape the product: Send feedback directly to our team at dev-feedback@writer.com.
• See it in action: Request a demo to learn how WRITER can help transform the way you build agents.