Agentify – Declarative AI Agent Prototyping in YAML

TL;DR

TL;DR: Agentify is a lightweight Python toolkit that lets you define AI agents with YAML instead of code — pick a model provider, write a role prompt, and run from the CLI.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: backplane-cloud/agentify-toolkit ← MUST visit and verify
• Source repository: github.com/backplane-cloud/agentify-toolkit ← MUST read README
• License: Apache 2.0 ← MUST verify from LICENSE file
• HN launch thread: news.ycombinator.com/item?id=47013725 ← verified via HN Algolia

What Is Agentify?

Agentify is a lightweight, declarative-first toolkit for prototyping AI agents in Python. The README describes it as:

Build and experiment with AI agents using simple declarative specs.

Instead of writing Python classes or wiring up framework logic, you define agents as YAML files and interact with them via a CLI. The toolkit handles provider routing, model selection, and the agent loop — your job is writing the role prompt.

Supported providers (auto-detected from environment):

• OpenAI (GPT-4 series)
• Anthropic (Claude series)
• Google (Gemini series)
• AWS Bedrock
• Mistral AI
• DeepSeek
• XAI (Grok)
• Ollama (local models)

Note from the README: Agentify is not a workflow orchestrator or production framework. It is for agent building, experimentation, and prototyping only.

Setup Workflow

Step 1: Install

pip install agentify-toolkit

Verify the CLI is available:

agentify --help

Step 2: Configure API Keys

Copy the example .env file:

cp .env.example .env

Populate it with your provider keys:

OPENAI_API_KEY=your-openai-key
ANTHROPIC_API_KEY=your-anthropic-key
DEEPSEEK_API_KEY=your-deepseek-key
MISTRAL_API_KEY=your-mistral-key
XAI_API_KEY=your-xai-key
GOOGLE_API_KEY=your-google-key
BEDROCK_API_KEY=your-bedrock-key
OLLAMA_API_KEY=your-ollama-key

Or use the CLI to add providers interactively:

agentify provider add anthropic
agentify provider list

All configured providers are automatically detected at runtime.

Step 3: Create an Agent

Option A — via CLI (interactive):

agentify agent new

The CLI prompts for: name, description, version, provider, model, api key, and role. The role is the system prompt that defines the agent’s persona.

Option B — manually via YAML:

# agent.yaml
name: claude
description: AI Security Engineer
version: 0.1.0
model:
  provider: anthropic
  id: claude-sonnet-4-5
  api_key_env: ANTHROPIC_API_KEY
role: |
  You are an AI Security Engineer.
  Provide concise, practical answers with examples.

Step 4: Run the Agent

agentify agent run agent.yaml

Step 5: Serve or Deploy

agentify serve agent.yaml
agentify deploy agent.yaml

Deeper Analysis

What makes it different: Most agent frameworks are library-first — you write Python code to define behavior. Agentify inverts this: you write YAML and the CLI drives everything. This makes it particularly fast for iteration on agent personas and model comparison.

Architecture as text diagram:

agent.yaml (YAML spec)
       │
       ▼
  agentify CLI
       │
       ▼
Provider router (reads .env, auto-detects available keys)
       │
       ▼
Selected model (OpenAI / Anthropic / DeepSeek / etc.)
       │
       ▼
Agent loop (role prompt + tool use)

Supported models per provider (from README):

| Provider | Example model | | ---------- | -------------------------- | | OpenAI | gpt-4 | | Anthropic | claude-sonnet-4-5 | | Google | gemini series | | DeepSeek | deepseek-chat | | Mistral AI | mistral series | | XAI | grok series | | AWS Bedrock| bedrock models | | Ollama | local models |

Limitations: The README explicitly states this is not for production workloads. For pipelines, multi-step workflows, or persistent memory, you would outgrow Agentify quickly. It shines at the prototyping stage.

Practical Evaluation Checklist

• pip install completes without errors
• agentify --help returns CLI help
• agentify provider add updates .env
• agentify agent new creates a valid agent.yaml
• agentify agent run produces a response from the configured model
• Multiple providers can coexist in .env without conflict

Security Notes

• API keys stored in .env — never commit this file to version control
• No tool use or file system access by default — agents are sandboxed to the model prompt loop
• Read the QUICKSTART for the full list of supported CLI commands

FAQ

Q: Can I use local models? A: Yes. Set up Ollama locally and configure OLLAMA_API_KEY in .env. The provider router auto-detects it.

Q: How is this different from LangChain or LlamaIndex? A: Those are library-first frameworks for building complex pipelines. Agentify is CLI-first and declarative — you write YAML, not Python code. It is purpose-built for rapid persona prototyping and model comparison.

Q: Does it support tool use? A: The README focuses on agent definition via role prompts. For extended capabilities, check the CLI reference in the repo.

Q: Is this production-ready? A: The README explicitly says no — it is for prototyping and experimentation. Use a proper orchestration framework for production workloads.

Conclusion

Agentify fills a specific niche: you want to test a new agent persona or compare model responses without scaffolding a Python project. Write a YAML file, run one command, iterate on the role prompt. If you outgrow it, you have a clear signal that the agent concept is worth building out properly.

To get started:

pip install agentify-toolkit
agentify agent new