PostKing Hackathon: 212 Marketing Tools for AI Agents

I built PostKing because I couldn't figure out distribution. Spent years writing good code, shipping decent products, and watching them land in silence. No traction, no audience, no feedback loop. The problem wasn't the product. It was that getting the word out required a completely different skill set, one I didn't have time to build from scratch every morning.

So when NVIDIA ran their Hermes + Stripe hackathon focused on tool-use for AI agents, I entered PostKing. The goal was concrete: expose PostKing's marketing infrastructure as callable tools that an AI agent, especially one running on NVIDIA's Nemotron model family, could actually use without human babysitting. We shipped 212 tools. They're live now.

This post explains what we built, why the architecture matters, and what it means if you're an indie founder, a small SaaS team, or an NGO trying to run consistent marketing without a full-time content department.

I just dropped @postkingapp Autonomous Marketing Agent - a reusable @NousResearch Hermes agent that takes one URL and a budget, pays for its own SaaS via @stripe, onboards your brand, and runs a full marketing operation: a week of social posts, a complete SEO roadmap, and a live landing page- all generated on @nvidia Nemotron 3 Ultra.

— Dité (@GashiDite) June 30, 2026

---

What the Hackathon Was Actually About

NVIDIA's hackathon wasn't a vibe session. It was scoped tightly around agentic tool use: giving AI models structured access to real APIs so they can take actions, not just generate text. Hermes (from Nous Research) is a model fine-tuned specifically for function-calling and tool orchestration. Stripe was there for payment-aware workflows. NVIDIA provided the compute infrastructure and Nemotron as the backbone reasoning model.

The prompt, loosely: build something an agent can run end-to-end. Not a chatbot. Not a wrapper. An agent that completes a task by calling real services in sequence.

For PostKing, that meant exposing our publishing, scheduling, brand voice, social distribution, and content generation pipelines as discrete, callable functions. Each tool has a schema. Each schema tells the model what inputs it needs, what it returns, and what it can chain into next.

The Nous Research Hermes model has been publicly documented as achieving strong performance on tool-calling benchmarks, including the Berkeley Function-Calling Leaderboard (BFCL), where structured output accuracy matters more than raw fluency. That benchmark rigor is what made it the right pairing for this kind of work. You can review the leaderboard data at gorilla.cs.berkeley.edu.

---

Why 212 Tools, Not 20

Early in scoping, I considered shipping a tight set: maybe 15-20 high-level tools. "Create a post." "Schedule content." "Publish to LinkedIn." Clean, simple, done.

The problem with that approach is granularity. An agent calling "CreatePost" as a single black box can't recover from partial failures, can't inspect intermediate state, and can't be steered mid-task. You end up with a system that either works perfectly or fails completely, with no useful signal in between.

Granular tools let the agent (and the developer watching it) understand exactly where in a workflow something went sideways. Did the brand voice check fail? Did the image resize step time out? Did the Stripe subscription check return an inactive status before the publish step ran? With 212 discrete tools, those questions have answers.

The 212 breaks down roughly like this:

• Content creation tools: drafting, editing, brand voice scoring, headline variants, meta description generation, alt text, thread formatting
• Publishing tools: platform-specific formatters, scheduling, queue management, retry logic, status checks
• Distribution tools: social channel connectors, RSS triggers, webhook dispatchers, newsletter payload builders
• Analytics tools: post performance reads, engagement summaries, best-time-to-post lookups
• Brand governance tools: tone checks, color palette validators for image descriptions, banned phrase scanners
• Billing and access tools: Stripe subscription status, seat checks, feature flag reads, usage meters

That last category, billing and access, is where Stripe tools made the whole thing coherent. An agent that can check whether a user's plan includes a given feature before attempting to call it is an agent that doesn't waste API budget on unauthorized requests or surface confusing errors to end users.

---

How Nemotron Fits In

NVIDIA's Nemotron model family sits at the reasoning layer. Where Hermes handles the mechanics of calling tools correctly, Nemotron handles the judgment: which tools to call, in what order, with what parameters, given a high-level goal.

In practice, during the hackathon, we tested a workflow like this:

Goal: "Write and publish a blog post about our new pricing update, in our brand voice, scheduled for Tuesday at 9am, and send a newsletter teaser."

Agent reasoning steps:
1. Call brand_voice_profile_get(org_id)
2. Call content_draft_create(topic, voice_profile)
3. Call brand_voice_score(draft_id)
4. If score < threshold: call content_revision_request(draft_id, feedback)
5. Call post_schedule(draft_id, platform="blog", time="Tuesday 09:00")
6. Call newsletter_teaser_generate(post_id)
7. Call newsletter_schedule(teaser_id, list_id, time="Tuesday 08:30")
8. Call stripe_feature_check(org_id, feature="newsletter_send")
9. If active: call newsletter_dispatch_confirm(teaser_id)

That sequence used 9 tools. None of them are hypothetical. They're live in the PostKing API. The Nemotron reasoning layer figured out the ordering, inserted the brand voice check, and put the Stripe feature gate in before the dispatch call, not after. That's the kind of judgment you want from a model handling production workflows.

NVIDIA's Nemotron-4 340B was released publicly with documented reasoning capabilities you can read about through NVIDIA's research page at research.nvidia.com. The smaller Nemotron variants used in this hackathon are optimized for lower-latency agentic use cases where you're chaining many tool calls in sequence.

---

What This Looks Like for an Indie Founder

Say you're running a SaaS product solo or with 1-2 other people. You ship a feature update. You know you should write about it, post about it, send a newsletter, update the changelog, maybe draft a short thread for social. In practice, most of that doesn't happen because you're already context-switching between support, code, and sales calls.

With PostKing's tools exposed to an agent, the workflow looks different. You describe the feature update in plain language. The agent pulls your brand voice profile, drafts the content, checks it against your tone guidelines, schedules it across your active channels, and queues the newsletter. You review the drafts (or you don't, if you've configured auto-publish for lower-stakes content). The work gets done.

That's not a fantasy. That's the actual capability the 212 tools enable when wired to a reasoning model. The gap between "we have a content backlog" and "content ships on schedule" gets smaller in proportion to how much of the workflow you can hand off to a tool-using agent.

For NGOs especially, the Stripe model matters differently. Many small nonprofits are grant-funded and run lean content operations. The ability to gate certain publishing features behind plan status means PostKing can offer tiered access without manual account management. An agent checking feature flags before executing expensive workflows keeps costs predictable.

---

Practical Setup: Getting Your Agent Connected

If you want to wire a Hermes or Nemotron-based agent to PostKing's tool suite, the setup path is documented in PostKing's developer API. A few things worth knowing before you start:

Authentication

Tool calls authenticate via a PostKing API key scoped to your organization. For agent workflows, we recommend creating a dedicated service key with read/write permissions on the specific resource types your agent needs. Don't hand your admin key to an agent. Scope it narrow, rotate it regularly.

Rate Limits and Retry Behavior

Some tools, particularly analytics reads and newsletter dispatches, have rate limits that matter in agentic contexts where the model might attempt rapid sequential calls. PostKing's retry tools are included in the 212: tool_call_retry(tool_name, params, backoff_strategy) lets the agent handle transient failures without you writing custom retry logic into your orchestration layer.

Audit Logging

Every tool call gets logged to PostKing's agent activity feed. If something goes wrong in a multi-step workflow, you can trace exactly which tool fired, what parameters it received, and what it returned. For teams running automated publishing, that audit trail is non-negotiable. You need to know what your agent did.

---

What We Learned From the Hackathon Build

A few things became clear during the build that probably aren't obvious from the outside.

First, the number of tools matters less than the quality of each tool's description. The model decides which tool to call based on the natural language description in the schema. Vague descriptions produce wrong tool selections. We rewrote descriptions several times during testing, each time making them more specific about preconditions, output format, and when not to use the tool. The quality of tool descriptions is roughly as important as the quality of the tool itself.

Second, Stripe's payment primitives are genuinely useful at the agent layer, not just the billing layer. Checking subscription status, reading usage meters, and confirming feature entitlements before taking action makes agents more reliable in production. An agent that fails gracefully because a feature isn't active on a plan is a much better user experience than one that throws a 403 mid-workflow with no explanation.

Third, keeping humans in the loop doesn't mean blocking the workflow on human approval for every step. It means designing review points at the right places: before first publish, before newsletter send, before any irreversible action. The rest can run autonomously. We built human_review_request(item_id, reason, urgency) as one of the 212 tools precisely because agentic systems that can't ask for help are fragile.

---

Best Practices for Running Marketing Agents in Production

If you're moving from "experimenting with agents" to "running agents against your live audience," here's what actually matters:

Start with read-only workflows

Before your agent publishes anything, run it in a mode where it only reads and drafts. Review the outputs for a week. Check whether the brand voice scores are landing where you expect. Adjust your voice profile if they're not. You want confidence in the agent's output quality before it starts shipping content to your audience.

Set hard limits on dispatch volume

An agent without volume constraints can technically publish 50 social posts in a day if you give it enough tasks. That's not a feature. Set daily and weekly caps per channel in your PostKing configuration. The agent will queue overflow content rather than blasting your followers.

Keep your brand voice profile current

Your voice profile should reflect how you actually write now, not how you wrote when you first set it up. Review it every quarter. If your product has matured, if your audience has shifted, or if your tone has naturally evolved, the profile needs to follow. An outdated voice profile produces content that feels slightly off in ways that are hard to explain but easy to feel.

Use the audit log as a feedback tool

Don't just check the audit log when something breaks. Review it weekly as a regular practice. Look at which tools the agent calls most, which ones it retries, and which workflows take the most steps. That data tells you where to improve your setup, whether that's better task descriptions, adjusted thresholds, or new tools that would short-circuit a multi-step chain.

Gate high-stakes actions behind Stripe checks

If your PostKing plan has newsletter send limits or per-seat publishing quotas, make sure your agent's workflows include Stripe feature checks before those actions. It's a small addition to any workflow and it prevents billing surprises and failed dispatches at the worst possible moment, usually right before a product launch.

---

Where This Goes Next

212 tools is a foundation. The roadmap from here runs toward deeper integrations: more social platforms, richer analytics tools, CRM connectors, and multi-agent coordination where a content agent and a distribution agent can hand off work to each other without a human bridging the gap.

The hackathon proved the architecture works. Nemotron can reason across a complex tool chain and produce workflows that actually match real marketing tasks. Hermes can call those tools accurately and handle the function-call mechanics cleanly. Stripe makes the whole thing commercially coherent at the agent layer, not just the account layer.

If you're building with AI agents and you need marketing infrastructure that your agent can actually call, PostKing's tool suite is live. The documentation is at PostKing's developer portal. Start with the brand voice tools. That's the piece most teams skip, and it's the piece that determines whether your automated content feels like yours or like everyone else's.

Distribution is still hard. But it's measurably less hard when your agent can do the repetitive parts correctly, consistently, without you having to remember to send the newsletter on Tuesday morning.