xGoals

Agents for Humans: Building xGoal, a Goal-Driven AI Agent for X

Inspiration

Everyone knows someone who does great work but goes quiet online.

Not because they have nothing to say. They simply don't have the time or energy to keep showing up.

A developer finishes an interesting project but never posts about it. A researcher discovers something useful but doesn't share it. A creator knows they should be engaging with their community but keeps putting it off.

The pattern is usually the same: open X, stare at the empty box, try to think of something worth saying, spend time writing it, look for people to engage with, and then do it all over again tomorrow.

The problem isn't a lack of ideas or talent.

It's consistency.

Existing tools solve parts of the problem. Content generators can write posts. Schedulers can publish them later. But you are still responsible for deciding what to talk about, who to engage with, and whether any of it is actually helping you reach your bigger goal.

So I started thinking about the problem differently.

What if you didn't start with a blank text box?

What if you started with a goal?

For example:

«"Help me become more visible in the AI agents community over the next 30 days."»

Instead of simply generating another post, an agent could use that goal as context and help you decide what useful action to take next.

That is the idea behind xGoal.

What xGoal Does

xGoal is a goal-driven AI content workspace for people who want to build a consistent and useful presence on X.

The starting point isn't a tweet.

It's the outcome you want.

You describe your niche, audience, expertise, and writing preferences. Then you create a goal in plain English, set its duration, and define what success looks like.

Once the goal is deployed, the agent works around that goal.

It can help discover relevant ideas, prepare draft posts, suggest conversations, and track progress toward the outcome.

For example, a developer might create a goal around becoming more visible in the AI developer community.

Instead of repeatedly asking:

«"What should I post today?"»

The work is connected back to the larger goal.

The user remains in control throughout the process. Drafts can be reviewed, edited, regenerated, rejected, or archived, and publishing requires explicit approval.

xGoal is intentionally not an autonomous posting bot.

The agent helps with the work.

You decide what represents you.

How I Built It

I wanted the experience to be simple.

The core workflow is:

Create a goal → Deploy it → Get useful actions → Review drafts → Approve → Track progress.

The application is built with TanStack Start, React, TypeScript, and Tailwind CSS.

Supabase handles authentication and persistent application data, including the state needed to manage goals and the agent's work.

The AI agent runs as a separate service. I built it with Strands Agents, which gives the agent a consistent structure while allowing me to work with different model providers.

The current implementation supports local Ollama development as well as Amazon Bedrock, OpenAI, and Groq model providers.

For X, xGoal uses OAuth 2.0 and keeps publishing behind explicit user approval. The application also separates drafting, approval, and publishing rather than treating them as one automated action.

The result is a system where the user's goal is the starting point, the agent handles the supporting work, and the user remains responsible for what ultimately gets published.

The Challenges

Building Something Around a Goal

The biggest challenge wasn't generating text.

It's easy to ask an AI to write a post.

The harder question was how to make the agent understand why that post should exist in the first place.

A goal like "grow my presence" is much more useful when it has a specific audience, timeframe, and definition of success.

That became an important part of the product: the goal isn't just something displayed on the dashboard. It is the context the agent works from.

Keeping the Human in Control

There is a big difference between helping someone communicate and speaking for them.

An agent that automatically posts might save time, but it can also publish something that doesn't sound like the person, makes an unsupported claim, or simply shouldn't have been posted.

That's why xGoal keeps drafting and publishing separate.

The agent can prepare the work, but the user makes the final decision.

Keeping the Scope Small

There were many directions I could have taken the project.

I could have built a traditional social media scheduler, a generic tweet generator, or a fully autonomous posting bot.

I deliberately didn't.

I wanted to focus on one simple idea:

Give an agent a goal and let it help you make progress toward it.

Everything in the MVP supports that idea.

What I'm Proud Of

I'm proud that xGoal has a clear product loop instead of being just an AI demo.

A user can define an outcome, deploy it, receive work related to that outcome, review what the agent prepares, and track progress.

I'm also happy with the way the agent layer is structured. Using Strands allowed me to keep the agent implementation separate from the rest of the application while supporting multiple model providers.

Most importantly, the project keeps the human in the loop.

The goal is not to make someone's X account look more active.

The goal is to help the person behind the account make meaningful progress.

What I Learned

Building xGoal changed how I think about AI agents.

A lot of AI products start with a task:

«"Write this."»

«"Summarize this."»

«"Find this."»

But people usually don't think about their lives in isolated tasks.

They think about outcomes.

A developer might want to become known for their work.

A creator might want to build a community.

Someone looking for a job might want to become more visible in their industry.

The individual tasks are just steps toward those outcomes.

That made me realize that the goal can be a much more powerful starting point for an agent than the task.

What's Next

The current version of xGoal is focused on helping users build a presence on X. The bigger direction is to eventually make the agent useful beyond X.

I want to give xGoal access to apps and tools so that, when a goal requires more than writing or researching, the agent can actually carry out the work.

For example, an agent working toward a community-building goal could eventually:

Generate images
Send emails
Create Google Forms
Communicate through WhatsApp
Send updates through Slack
Communicate in Discord
And use other applications required to accomplish the goal

Imagine telling xGoal:

«"Help me organize a developer community event in the next 30 days."»

Today, xGoal can help with the content and conversations around that goal.

Eventually, I want the agent to be able to help with the actual execution too: create the registration form, prepare promotional material, send messages, communicate with the community, and keep track of what still needs to happen.

That is the direction I want to take xGoal:

You define the outcome. The agent figures out the work. Your tools become its hands. And you remain in control.