explainx / blog
Set Codex goals remotely via Telegram, track them in a Kanban board, and watch autonomous agents execute complex tasks in the wild. Here's how this workflow changes everything.
May 12, 2026
Goal mode is an autonomous agent loop where you define a completion condition—like 'all tests passing' or 'vulnerability patched'—and the agent iterates continuously (plan → act → test → review) until the goal is met or your budget is exhausted. Unlike traditional prompt-response cycles, goal mode enables true hands-off automation for complex, multi-step tasks.
Jun 28, 2026
Four serious tools now compete for the same territory: no-code and low-code AI workflow building. Langflow, n8n, Make, and Flowise are not interchangeable. This comparison breaks down what each tool actually does well, where each one falls short, and gives you a three-question framework to pick the right one for what you are building in 2026.
Jun 24, 2026
Hermes Agent (188k stars, Nous Research) and OpenClaw (247k stars, Peter Steinberger / OpenClaw Foundation) are both local-first, model-agnostic, MIT-licensed agent runtimes. But they have fundamentally different architectures: Hermes packages a learning loop around a messaging gateway, OpenClaw packages an agent around a messaging gateway. That difference drives everything else.
What: A workflow that combines Codex's /goal command with Hermes Agent, Telegram, and Kanban tracking to create a remote-controlled, fully observable AI agent system.
Why it matters: Set complex coding goals from anywhere via Telegram, watch Codex execute them autonomously, and track progress visually on a Kanban board. This workflow transforms AI agents from interactive assistants into reliable, auditable autonomous workers.
Who built it: Shubham Saboo, Senior AI Product Manager at Google and creator of Awesome LLM Apps (109,000+ GitHub stars), shared this breakthrough workflow on Twitter/X on May 10, 2026.
Key insight: The underrated component is the state surface—Telegram provides the command layer, but once goals become Kanban cards, you can audit, pause, and steer Codex instead of hoping the agent loop stays sane.
Traditional AI agent interactions require you to be at your terminal, monitoring progress, responding to questions, and guiding the agent through complex tasks. The moment you step away, the agent sits idle.
This workflow shatters that constraint.
With Codex /goal orchestrated by Hermes Agent and controlled via Telegram, you get:
As Shubham put it: "I updated my Hermes agent skill to give Codex a goal on the fly using Telegram and track each one of those codex goals in a Kanban board. It has been really insane to see and track Codex execute goals in the wild."
Codex is Anthropic's official command-line interface for Claude, designed specifically for software engineering tasks. Unlike Claude.ai's web interface, Codex is built for developers who want deep filesystem integration, git operations, and autonomous code execution.
The /goal command is Codex's most powerful feature. Instead of giving the agent a single task, you define a high-level objective and let Codex figure out the implementation details.
Example goals:
/goal Refactor the authentication system to use JWT tokens/goal Add comprehensive test coverage for the payment processing module/goal Optimize database queries in the user service to reduce latency by 50%Codex will:
The key difference from normal chat: Codex keeps working toward the goal even when it encounters obstacles, rather than stopping and asking you what to do next.
Hermes Agent is an AI agent framework that extends Claude's capabilities through custom skills. Think of it as middleware between your commands and Codex execution.
In this workflow, Hermes acts as the orchestrator:
/goal invocationsThis orchestration layer is critical because it decouples the command interface (Telegram) from the execution engine (Codex), making the system modular and extensible.
Why Telegram? Several reasons:
You send a message like:
/goal Implement caching for the user profile API using Redis
Hermes receives it, starts a Codex goal, creates a Kanban card, and replies:
✅ Goal created: #42 - Implement caching for user profile API
📊 Track progress: https://trello.com/c/abc123
You're now free to do anything else. Codex is working autonomously.
This is what Alex Harmon called "the underrated bit" in his response to Shubham's tweet:
"Telegram is a great command layer, but once goals become Kanban cards you can actually audit, pause, and steer Codex instead of hoping the agent loop stays sane."
The Kanban board transforms invisible agent state into visual, actionable information.
Typical Kanban columns:
Each card contains:
This visibility is crucial for production use. You can:
Here's a complete walkthrough of the workflow in action:
Open Telegram and message your Hermes bot:
/goal Add rate limiting to all API endpoints using Express middleware.
Apply 100 requests per minute for authenticated users and 20 for anonymous.
Add Redis for distributed rate limit tracking. Include tests.
The Hermes Agent skill:
/goal commandYou receive:
🚀 Goal #47 started
📋 Title: Add rate limiting to API endpoints
📊 Track: https://linear.app/team/issue/47
⏱️ Started: 2026-05-11 14:32 UTC
Codex analyzes your codebase:
express-rate-limit, rate-limit-redis)All of this happens without you being involved. Codex makes decisions based on best practices, your codebase patterns, and the goal parameters.
Open your Kanban board and see:
Card #47: Add rate limiting to API endpoints
The card updates in real-time as Codex progresses.
When Codex finishes, you get a Telegram notification:
✅ Goal #47 completed successfully!
⏱️ Duration: 8 minutes
📝 Files changed: 5
✅ Tests passing: 12/12
🔗 View changes: https://github.com/user/repo/compare/main...rate-limiting
📊 Card: https://linear.app/team/issue/47
The Kanban card moves to "Review" status, waiting for your approval.
You review the changes when convenient:
If you need changes:
/goal [#47] Reduce authenticated rate limit to 50 requests per minute
Codex will continue from where it left off, making the requested adjustment.
Let's compare this approach to other AI agent workflows:
| Approach | Remote Control | Autonomous | Observable | Auditable | Multi-Agent |
|---|---|---|---|---|---|
| Codex /goal + Telegram + Kanban | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes |
| ChatGPT / Claude.ai web | ❌ No | ⚠️ Limited | ❌ No | ⚠️ Limited | ❌ No |
| Copilot / Cursor inline | ❌ No | ❌ No | ✅ Yes | ❌ No | ❌ No |
| Raw Codex CLI | ❌ No | ✅ Yes | ⚠️ Terminal only | ⚠️ Limited | ⚠️ Limited |
| GitHub Copilot Workspace | ⚠️ Web only | ✅ Yes | ✅ Yes | ✅ Yes | ⚠️ Limited |
Key advantages:
As Ming commented on Shubham's tweet: "/goal is one of the most innovative commands. I just cancelled my Claude max and will move to codex /goal."
Want to replicate this workflow? Here's how:
Codex CLI installed and authenticated
npm install -g @anthropics/claude-code
codex auth
Hermes Agent set up with custom skills
Telegram Bot created via BotFather
Kanban board (choose one):
Step 1: Create the Hermes skill
Create a new Hermes skill file: hermes-codex-orchestrator.yaml
name: codex-goal-orchestrator
description: Orchestrate Codex /goal execution via Telegram with Kanban tracking
triggers:
- telegram_command: /goal
- telegram_pattern: "^goal:"
actions:
- parse_goal_from_message
- validate_repo_state
- create_kanban_card
- invoke_codex_goal
- send_confirmation
- monitor_progress
- update_kanban_status
- send_completion_notification
integrations:
- telegram
- codex_cli
- kanban_api
Step 2: Configure Telegram integration
In your Hermes config, add the Telegram bot credentials:
telegram:
bot_token: ${TELEGRAM_BOT_TOKEN}
allowed_users:
- your_telegram_user_id
webhook_url: https://your-server.com/webhook
Step 3: Configure Kanban integration
Add your Kanban board API credentials:
kanban:
provider: linear # or trello, notion, github
api_key: ${LINEAR_API_KEY}
team_id: your-team-id
project_id: codex-goals
default_labels:
- codex-automated
- needs-review
Step 4: Create the orchestration logic
Write the orchestration script (pseudocode):
async def handle_telegram_goal(message):
# Parse goal from message
goal_text = extract_goal(message.text)
# Validate repo state
if not is_repo_clean():
return send_telegram_message("Repo has uncommitted changes. Clean up first.")
# Create Kanban card
card = create_kanban_card({
'title': f"Codex Goal: {goal_text[:50]}...",
'description': goal_text,
'status': 'In Progress',
'labels': ['codex-automated'],
'metadata': {
'telegram_user': message.from_user.id,
'started_at': datetime.now(),
'repo': get_current_repo()
}
})
# Invoke Codex goal
codex_session = subprocess.Popen(
['codex', 'goal', goal_text],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
# Send confirmation
send_telegram_message(f"✅ Goal #{card.id} started\n📊 Track: {card.url}")
# Monitor progress in background
asyncio.create_task(monitor_codex_progress(codex_session, card))
async def monitor_codex_progress(session, card):
while session.poll() is None:
# Stream output and update card
output = session.stdout.readline()
append_to_card_activity(card.id, output)
await asyncio.sleep(1)
# Goal completed
session.returncode == :
update_kanban_card(card., {: })
send_telegram_message()
:
update_kanban_card(card., {: })
send_telegram_message()
Step 5: Deploy and test
/goal Create a simple hello world endpoint at /api/hello
This workflow shines in specific scenarios:
Set goals during your morning commute:
/goal Refactor the authentication module to use our new JWT utilities
/goal Add pagination to the users list endpoint
/goal Update all dependencies and fix breaking changes
By the time you arrive at your desk, Codex has made significant progress (or completed) all three goals. You review, approve, and merge.
During a product meeting, you realize you need a new feature:
/goal Add export to CSV functionality for the reports page with download button
While you continue the meeting, Codex implements the feature. You demo it at the end of the meeting.
Before leaving work on Friday:
/goal Upgrade to Next.js 15 and fix any breaking changes
/goal Run security audit and fix all high severity vulnerabilities
/goal Optimize bundle size by analyzing and removing unused dependencies
The weekend bot runs these maintenance tasks. Monday morning, you review the changes and deploy.
Testing multiple approaches:
/goal Implement dark mode using CSS variables approach
/goal Implement dark mode using Tailwind dark: classes
/goal Implement dark mode using next-themes library
Three parallel Codex sessions try different approaches. You review all three and pick the best one.
For new team members:
/goal Set up the development environment following our docs/setup.md guide
/goal Run the test suite and fix any failing tests
/goal Add yourself to the team page with bio and photo
New developers get instant automated onboarding support.
The Twitter thread generated significant discussion. Here are key insights from the community:
Alex Harmon (@alexharmondev) highlighted the critical insight:
"The underrated bit is the state surface. Telegram is a great command layer, but once goals become Kanban cards you can actually audit, pause, and steer Codex instead of hoping the agent loop stays sane."
This is the key architectural principle: Agent autonomy is only valuable when paired with observability and control. The Kanban board provides that control surface.
Ryan Ravenson noted:
"only way a windows user can use it!"
This highlights that the workflow democratizes access to powerful agent capabilities across all platforms.
David Prentice asked about the relationship with Hermes /goal:
"So if understand correctly its goal is to promote codex native cli? Because Hermes /goal has a 20 turn limit"
Shubham clarified:
"It is the orchestrator for codex goal. Run and track on kanban"
This distinction matters: Hermes is not executing the goal—it's orchestrating Codex's native goal execution. This bypasses Hermes's turn limits while adding orchestration capabilities.
Barron Roth asked how the agent controls Codex:
"how does your agent control codex?"
Shubham's answer:
"via codex CLI"
Simple but powerful: Hermes invokes Codex as a subprocess, monitoring its stdout/stderr and updating the Kanban board based on Codex's progress.
Based on the workflow design and community feedback:
Good goals:
/goal Add input validation to the signup form: email must be valid format,
password must be 8+ chars with 1 number and 1 special char. Show inline errors.
Bad goals:
/goal improve signup
Specificity helps Codex make the right decisions autonomously.
When you need to modify a goal:
/goal [#47] Change rate limit to 50 requests per minute instead of 100
The [#47] reference tells Hermes to continue working on card 47 rather than creating a new goal.
Configure Telegram notifications for:
Don't notify for:
Too many notifications defeat the purpose of async operation.
Set a daily routine:
On your Kanban board:
feature, bugfix, refactor, choreurgent, normal, lowneeds-review, breaking-change, experimentalThis makes it easier to decide what to review first.
Codex goals can be computationally expensive. Track:
Optimize your goal-setting strategy based on these metrics.
This workflow isn't perfect. Here are current challenges:
If a goal is unclear, Codex might make wrong assumptions. Unlike interactive mode, you can't clarify mid-execution.
Mitigation: Write very specific goals with acceptance criteria. Use examples when possible.
Goals that require external services, API keys, or manual steps can get blocked.
Mitigation: Ensure your environment is fully set up before setting goals. Use environment variable checks in your orchestration script.
If you're working on the same codebase while Codex is executing a goal, you might create merge conflicts.
Mitigation: Use branch isolation. Have Hermes create a new branch for each goal automatically.
Running multiple goals in parallel can consume significant API credits.
Mitigation: Set concurrency limits. Configure Hermes to queue goals and run at most N in parallel.
Giving an agent autonomous control of your codebase requires trust.
Mitigation:
This workflow represents a paradigm shift in how we work with AI agents. Instead of treating agents as interactive assistants, we're treating them as autonomous workers that we orchestrate and supervise.
Key principles emerging:
As Shubham said: "It has been really insane to see and track Codex execute goals in the wild."
The "in the wild" part is key. We're moving from AI agents as laboratory experiments to AI agents as production tools.
Ready to try this workflow?
Immediate next steps:
Install Codex CLI: Get familiar with /goal command
npm install -g @anthropics/claude-code
codex auth
codex goal "Create a simple hello world endpoint"
Try manual Kanban tracking: Before automating, manually track a few Codex goals on a Kanban board. This helps you understand what state information matters.
Set up Telegram bot: Create a simple bot that receives messages. Start with a manual flow where you copy/paste goals from Telegram to Codex.
Automate incrementally:
Join the community: Follow Shubham Saboo and the broader AI agent community to see how others are iterating on this workflow.
The Codex /goal + Hermes Agent + Telegram + Kanban workflow represents a breakthrough in making AI agents truly autonomous yet controllable. By combining:
We get a system that's greater than the sum of its parts. As Tech With Matteo commented: "setting goals via Telegram and tracking them in a Kanban is such a clean setup honestly."
Clean, powerful, and—as Shubham demonstrated—life-changing.
Interested in learning more about AI agents and automation workflows? Check out these related articles:
Have you tried the Codex /goal workflow? Share your experience or questions with the explainx.ai team on Twitter/X or in our community Discord.
explainx.ai helps teams understand, monitor, and improve their AI systems. Learn more at explainx.ai.