Today, we’re taking a massive step in that direction.

⏰ Introducing Agent Scheduling: Your Agents, Now on Autopilot

You’ve built a powerful agent. Why should it wait for you to press a button? With our new Agent Schedules, you can put your agents to work automatically, turning them into reliable, autonomous members of your team.

This is more than just a simple timer; it’s a full-featured scheduling engine designed for flexibility and control.

• Total Control: A new “Schedules” page in the Console gives you a single place to create, manage, pause, and monitor all your scheduled agent runs.

• Consistent Execution: Pre-configure your agent’s inputs for each schedule. Whether it’s running a daily report or a weekly data sync, you can set it once and trust it will run correctly every time.

• Precision Timing: Full timezone support means your agents run exactly when you intend them to, automatically handling details like daylight saving time.

• Powerful & Flexible: We use standard cron expressions to give you complete control over your schedule, from running every five minutes to executing on the third Tuesday of every month.

✨ The Magic of AI-Powered Cron

Let’s be honest, `0 17 * * 1-5` isn’t exactly intuitive. While cron is powerful, writing expressions can be a chore. So, we fixed it.

Our new schedule creator includes an AI-powered helper that turns plain English into a valid cron expression.

Just type “Every Monday and Friday at 9am PST,” and we’ll generate the matching cron expression for you.

Even better, we translate any existing cron expression back into a human-readable description. This means you can build complex schedules with confidence, knowing exactly what they’re set to do. No more trips to a cron helper website.

This update fundamentally changes what you can build with Ag.dev. Agents are no longer just tools to be executed; they are processes to be deployed. You can build agents that check for new leads every morning, summarize market news every hour, or perform maintenance tasks every weekend—all without any manual intervention.

This is the next step toward building a true, professional-grade platform for scaling autonomous agents.

Log in to the Console to schedule your first agent. We can’t wait to see what you automate.

Happy automating

Here’s a look at what’s new.

🚀 Introducing Agent Versioning: Ship with Confidence

Building agents is an iterative process. You tweak a prompt, add a new tool, or edit the schema, but every change carries the risk of breaking a previously working version. Until now.

We're excited to introduce a full Agent Versioning System. Think of it as Git for your agents.

• Automatic Revisions: Every time you update an agent, we automatically save a new revision.

• Publish & Run: You can now "publish" a specific version as the stable, default release. When you execute an agent, you can choose to run the published version or any other specific revision, making it safe to experiment without disrupting production workflows.

• Compare & Rollback: Easily see the differences between revisions and roll back to a previous version if an experiment doesn't pan out.

This is a foundational change that enables more complex, professional development workflows. You can now build, test, and deploy with the safety and confidence you're used to with traditional software development.

🐍 Unleash Your Agents with Code Interpreter

This is a big one. We've added a powerful new Code Interpreter tool, giving your agents the ability to write and execute Python code and shell commands within an isolated sandbox environment.

This unlocks a massive new landscape of possibilities. Your agents are no longer limited to predefined tools; they can now:

• Perform complex data analysis and calculations on the fly

• Manipulate files and interact with the filesystem

• Call other command-line tools to accomplish tasks

• Dynamically generate and run scripts to solve novel problems

The Code Interpreter fundamentally expands what an agent can do, moving them closer to true autonomous problem-solving.

✨ Faster Creation, Easier Management

Beyond the headline features, we’ve shipped a series of significant quality-of-life improvements based directly on your feedback:

• Generate Schemas from Prompts: Kickstarting a new agent just got much faster. Our new AI-powered service can analyze your goal prompt and instructions to automatically generate a suggested input schema. Less time writing boilerplate JSON, more time building.

• Flexible, Input-Free Agents: Not every agent needs complex inputs. We’ve removed the requirement for input parameters, so you can create simple, single-purpose agents with less friction.

• Clean Up Your Workspace: You can now safely delete old or experimental agents. A simple but essential feature for keeping your Console organized.

We’re incredibly excited about this latest batch of updates and the foundation they lay for what's coming next. We're focused on building the most robust and developer-centric platform for creating, testing, and scaling agents, and that means giving you the robust, professional tools you need to do your best work.

Log in to the Console to check out the new features. We can't wait to see what you build with them.

Happy building!

Find out more about:

• What Ag.dev is and why it’s different

• A concrete “deep company research” example you can build in minutes

• How to join our community and share feedback

What is Ag.dev?

Ag.dev is a development platform for “headless agents” — autonomous AI workers that run in the background, triggered by events or API calls, and return structured, production-ready results.

Instead of wiring complex orchestration logic, you describe:

• The agent’s goal and constraints in natural language

• The tools it’s allowed to use (web search, news, browsing, or your own via MCP)

• The input schema it accepts and the output format it must produce

Ag.dev handles execution, observability (full run traces), and scaling (API + managed infrastructure).

Why teams use Ag.dev:

• Automation at the speed of prompt: No code required to define, test, and iterate.

• Full observability: See planning, reasoning, and tool calls for every run.

• Scales by design: One-click deploy; invoke via API/webhooks; batch across thousands of inputs.

• Extensible: Connect private systems via MCP for secure, high-trust automation.

• Predictable outputs: Return documents or schema-validated JSON.

Getting Started: Build a “Deep Research Profile” Agent

In this example, you’ll create a headless agent that produces a detailed, narrative research brief for a target company. The output will be a document (not JSON).

Get started:

• Sign up: https://auth.ag.dev/signup

• Quickstart: https://docs.ag.dev/quickstart

Step 1 — Create an Agent

Configure the agent with:

• Output format: Document (text)

• Built-in tools: Enable Web Search, News, and Browse Website

• Model: Choose a model suited to research tasks (you can adjust later)

Goal Prompt (templated with Handlebars):

You are a meticulous market research analyst.

Task:
Create a deep research profile for {{ company }}

Instructions:
- Prioritize authoritative sources and recent information (past 12–18 months).
- Cross-check claims; avoid speculation. If data is unavailable, note the gap.

Deliverable (Document):
Include clear section headings and concise, source-backed content:

1. Company Overview
2. Key Persons
3. Latest News

Constraints:
- Be objective and succinct.
- If browsing reveals conflicting data, explain the discrepancy and favor more recent primary sources.

Step 2 — Define the Input Schema

Use JSON Schema to specify the inputs your agent expects. For this example, the only required field is company, with optional fields for disambiguation.

{
  "type": "object",
  "required": ["company"],
  "properties": {
    "company": { "type": "string", "description": "Target company name" }
  }
}

Step 3 — Configure Tools and Settings

• Select a model stack for your Agent, for example “openai/reasoning-low”. This model stack uses reasoning models with low reasoning time to create and update the agent's plan.

• In the advanced settings section, enable the context compression. This option compresses the context of your agent while running on a regular basis and enables long-running and complex tasks to run without hitting a context lenght limit.

Step 4 — Test Your Agent

• Provide a sample input, for example:

  • { "company": "ACME Inc."}

• Start a test run and watch the live event stream:

  • reasoning: intermediate thinking as it evaluates sources

  • tool_call: search, news, and browse actions with parameters

• Refine quickly:

  • Tighten or expand the instructions

  • Emphasize recency or specific data ranges

  • Adjust headings or tone to match your brand

Tip: If you see noisy sources in the trace, add directives like “favor primary sources (company site, filings, reputable outlets); deprioritize low-authority blogs.”

Step 5 — Deploy and Integrate

• Save your agent to deploy to enable production runs.

• Invoke via API/webhooks from your product, CRM, data pipelines, or internal tools.

• Batch runs: feed a list of companies to generate many profiles in parallel.

Minimal invocation pattern (illustrative):

# Create a run
curl -X POST "https://api.ag.dev/agents/{AGENT_ID}/runs" \
-H "Authorization: Bearer YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"input": { "company": "ACME Inc."}
}'
# Poll run status or subscribe to events, then fetch the final document result

The run result will contain your document output plus a list of sources if browsing was used.

Step 6 — Extend with Your Tools (Optional)

• Connect internal systems via MCP (e.g., CRM, data warehouse, procurement, ticketing).

• Expose only the functions your agent needs and keep strong boundaries.

• Re-test with observability to validate behavior before scaling.

What You Can Automate Today

• Sales and market research: Generate deep company or account briefs on demand.

• Data enrichment and analysis: Summaries, watchlists, and change detection.

• Personalization at scale: Tailored onboarding or outreach content based on fresh research.

• Content generation: Reports, memos, and structured documents ready for stakeholders.

Who the Ag.dev Early Access Is For

• Builders in operations, marketing, sales, product, and data who need event-driven, repeatable automation—not another chat UI.

• Teams that require dependable outputs and transparent audit trails.

• Organizations planning to connect private data and APIs in a secure, observable way.

What to expect in the early access:

• A stable core with rapid iteration on ergonomics, observability, and integrations.

• Help from our team to ship your first agent to production.

• Early access features; we’ll communicate any breaking changes in advance.

• Notes: The early access version is hosted in the US and we are currently logging all interactions, agents and agent runs in full text to improve our platform. The platform is provided as is and is subject to change and further improvements.

Join the Community: Need Help? Want Feedback?

• Sign up: https://auth.ag.dev/signup

• Quickstart: https://docs.ag.dev/quickstart

• Join the Ag Discord: https://discord.gg/cPSJbuKDse

Tell us what you’re building, share your prompts, and get rapid help from the team and other builders. We’re especially eager for feedback on:

• Goal Prompt ergonomics and document formatting controls

• Tooling gaps (built-in vs. MCP integrations)

• Which traces/logs make you fastest to production

• Batch and webhook patterns you rely on

Let’s build reliable, headless automation—at the speed of prompt.