Video Companion

How I Integrated OpenClaw with StartInfinity (Full Tutorial + Prompt)

YouTube Description

+

## 🔥 Get the Exact Prompt 👉 https://thomasfellows.com --- ## ⏱️ Chapters 00:00 – Intro 00:03 – What This Integration Does 00:15 – The Core Problem (No Context) 00:39 – Why Context Matters for AI Agents 00:42 – My Original Setup (OpenClaw + Obsidian) 01:15 – Why Markdown Systems Break Down 02:00 – The Idea: StartInfinity Integration 02:30 – What the Plugin Does 03:30 – How It Works Inside StartInfinity 04:30 – Challenges I Ran Into 05:30 – Building the Integration 06:30 – Final Result 07:30 – How You Can Recreate This --- ## 🧰 Resources Mentioned * **OpenClaw** – https://openclaw.ai * **StartInfinity** – https://startinfinity.com * **StartInfinity Developer Docs** – https://devdocs.startinfinity.com/ * **Obsidian** (used for original setup) – https://obsidian.md --- ## 🚀 How I Integrated OpenClaw with StartInfinity In this video, I show you how I built a custom plugin for **OpenClaw** that integrates directly with **StartInfinity** and why it completely changed how my AI agents work. The biggest issue I ran into was this: 👉 My agents didn’t have enough **context** to be useful. Everything lived in markdown files inside my workspace, and while that worked at first, it quickly became messy and hard to manage, both for me and for the agents trying to use that information. So I built a better system. --- ## 🧠 What You’ll Learn * Why context is the most important part of AI agents * The limitations of markdown-based workflows * How structured systems like StartInfinity improve performance * How I connected OpenClaw to an external tool * What the plugin actually does * The exact approach you can use to recreate it --- ## ⚡ Why This Matters If your AI agents feel: * Confused * Limited * Not that helpful It’s probably not the model. It’s the **lack of structured, accessible context**. This integration solves that problem by giving your agents a clean, organized system to work with. --- ## 📌 Final Thoughts This is just one way to extend what AI agents can do when you combine them with the right tools. Once you start connecting systems like this, things get a lot more powerful. --- ## 🔔 Subscribe If you’re interested in: * AI workflows * Automation systems * Building with tools like OpenClaw 👉 Make sure to subscribe for more ---

Published

April 2, 2026

Tags

Transcript

+

In this video, I'm going to show you how I used OpenClaw to create a plugin for itself that integrates with Start Infinity. I'm going to show you why I did it, what the plugin can do inside of Start Infinity, the problems that I had while creating it, and then the prompt that you can use if you want to recreate it yourself. The main problem that I was trying to solve was that the agents I was using inside of OpenClaw didn't have the full context of the tasks I was doing or the projects I had running. It just didn't seem to be working very well, because context is what matters most when using the agents inside of OpenClaw. I had my workspace for my OpenClaw agent inside of Obsidian, and it was enough at the start, but the markdown files ended up getting a little bit confusing. If you are running and keeping check of all of your projects inside of markdown files and all the tasks just as a person, it's not easy to keep track of. And when the projects and tasks live inside a workspace for one agent, if you create another agent inside of OpenClaw, it has its own workspace. As the docs say, an agent is fully scoped with its own workspace, state directory, and session store. So each agent has its own workspace, and it can't really read the projects and tasks that I've been building with that other agent. It just wasn't an optimal solution. Then I tried Google Tasks, and that was a little bit better because OpenClaw has a CLI integration that makes it really easy for it to control things you use inside of Google Workspace. So the integration worked really well, and OpenClaw could create tasks, read them, and do all that type of thing really well. But for me it just didn't fit my working style. I didn't have enough context around the things I was working on. It was just a few lists of tasks, and I wanted a more robust solution for myself, even though OpenClaw used it really well. So what I did was go back to the tool that I like using, which is Start Infinity. I actually got this LTD back in 2019 inside of the MarkTech group. That's when people would send these T-shirts. They sent me this shirt all the way back then. Back in 2019, SaaS companies would send shirts to get the word out, but my son can read now, so I can't wear it anymore, and I'm actually surprised that my wife hasn't thrown it out. But anyway, Start Infinity is the project management system that I originally liked using, and then I remembered that they have API documentation here. It's quite extensive, so I figured I would just tell OpenClaw to build the integration for me and see what would happen. The main thing I was trying to solve was that I wanted something that was easy for me to use, easy for me to keep track of the context of my projects and tasks myself, and then something that's easy for OpenClaw to see, and also that multiple agents can get context from one source. In order for you to see what OpenClaw can do with the integration that I built, I'll go ahead and show you my Start Infinity boards. These are some old boards I haven't been using, and here's my LTD board. It's not up to date and I need to update it. It just lists a bunch of LTDs I've bought over the years, dating back to maybe 2018. That's the board we'll take a look at. If I go over to OpenClaw and ask it, "What boards do you see inside of the personal workspace in Start Infinity?" you can see the tool calls right up here. It was able to bring back the boards from my personal workspace, and there it is. Then I tried something else. On the LTD board, I asked, "What is the most expensive item and when was it purchased?" It said the most expensive one was RingTannic, purchased November 29th. So I went over to the board and took a look, and there it was. The integration was working pretty well. Then I tried one more thing. On the LTD board, I told it to create one new item. I bought Privy about four days ago from AppSumo for $39, and in the notes I used a $25 credit. I couldn't remember if that was the real price, but my credit was about to expire so I hurried up and used it. It said it added the item, so I went ahead and looked. It said Privy, not "in Privy," from AppSumo, $39, March 29th, and used a $25 credit. As you can see, the integration is working out pretty well. So let's go ahead and see how that was done. At first I just told OpenClaw to create the integration using the API documentation from Start Infinity, and I told it that I wanted to be able to read the boards and the items on them, that type of thing. What it started doing was making a local MCP server on my computer, and then OpenClaw would use that MCP server along with the API integration to read stuff in Start Infinity. The computer was able to read the items on Start Infinity, but the agent itself was not able to. So it basically told me the MCP integration route was not correct and wasn't going to work long term. It told me to create a native plugin inside of OpenClaw instead, and that's the direction we ended up going. After I was done making the integration for myself, I told OpenClaw to create this document so I could pass it off to anyone else who wanted to create the same integration. I'm not going to show you how to build it live, because when you use OpenClaw to build an integration like this, it is probabilistic, not deterministic. That means everybody's going to have a different result. Your setup is different than mine, and you're going to run into different snags than I did. So this is the document, and you're going to end up with a native OpenClaw plugin for Start Infinity. Basically, you need to get your Infinity token inside your account, and then you'll be able to read workspaces, boards, folders, attributes, and items, and you'll be able to create, update, and archive items. There's a lot more you can do with the integration if you want to. If you go over to the API documentation, there are a lot more permissions you could give it. It's up to you how many permissions you want to give to OpenClaw, because you don't want it to end up deleting all your boards. You just have to be careful with that. In order to get the token, what you're going to need to do is go over to Start Infinity, click your profile picture, go to My Profile, and at the bottom of the profile enable Developer Features and enable API Dev Helper. Once you do that, you'll have a Developer menu item on the left. Then you go to Tokens and create a new token, and you'll only see this token once. If you want, you can go ahead and save it somewhere that you like. The document says to put the token in the right place. Actually, that's not the way I did it. That is probably the way you should do it, but what I did was make a text file on my desktop, and then I told OpenClaw to take it from there and put it in a place that doesn't expose it inside of a chat session. I didn't paste it into the chat session, so it isn't inside of the logs. That's up to you. Then it's going to create these files, so you don't really need to worry about that. Here's the prompt that you're going to be using, and it tells you the initial tools it's going to expose. Again, if you want it to have more permissions, you can probably just put in plain English what you want it to be able to do and it will take care of it. One thing I noticed while running this is that it did have problems finding the token at the proper time. You may run into a snag where you have to keep telling it to move the token to this place or move it there and use it at the right time. That's one of the things that I ran into as well. After that, you can go through the verification. Basically, you're just going to try to see if it works, and there are more prompts to verify it if you'd like. There are also common mistakes it should avoid after I've already done it. This prompt will be available on thomasfellows.com if you want to use it. Hopefully that's helpful for you and you can create that integration for yourself between Start Infinity and OpenClaw. If you want more content like this, please hit subscribe. Thank you for watching. Have a good day.

Beyond The Video

Companion Updates

This walkthrough is really about context design, not just plugin setup. It shows why agent performance starts breaking down when projects live in scattered per-agent files, why a structured external system works better for shared visibility, and what a usable native OpenClaw integration looks like once it can read real boards and write real items.

Key Takeaways

The real bottleneck was not model quality. It was the lack of shared, structured context across agent workspaces.
Markdown notes and simple task lists can work early, but they get brittle once multiple agents need access to the same project state.
The first MCP-style approach could read data at the machine level, but it did not solve the normal agent-path usability problem.
A native OpenClaw plugin was the right abstraction because it exposed the integration where day-to-day agents could actually use it.
Good verification matters: this workflow checks real workspaces, boards, attributes, items, and write actions instead of stopping after a basic API test.

Best Suited For

This video is best for builders who already use AI agents but keep running into context limits, fragmented project memory, or awkward task-tracking workflows. If you want your agents to read from a structured system, write back to it, and operate through the normal OpenClaw tool path instead of a one-off shell workaround, this is a very practical watch.

If your goal is to recreate the working setup shown in the video, the handoff guide below turns the walkthrough into a concrete build-and-verify checklist.

End Result

When this is finished, the person should have:

a working native OpenClaw plugin for Start Infinity
one shared Infinity integration that normal OpenClaw agents can use
the Infinity token stored in ~/.openclaw/.env
working tools for reading workspaces, boards, folders, attributes, and items
working tools for creating, updating, and archiving items
basic docs in the plugin folder

Before Starting

1. Get a Start Infinity Token

In Start Infinity:

click your profile picture
click Settings
at the bottom of the profile/settings screen, enable:
- Developer Features
- API Dev Helper
create or copy your Personal Access Token

2. Put the Token in the Right Place

Store the token in:

~/.openclaw/.env

Add this line:

INFINITY_TOKEN=your-start-infinity-token-here

Important:

do not put the raw token in chat
do not hardcode the raw token into plugin source files
do not store the raw token directly in openclaw.json

What the Builder Should Create

Inside the workspace:

integrations/infinity-native-plugin/package.json
integrations/infinity-native-plugin/openclaw.plugin.json
integrations/infinity-native-plugin/index.js

And the plugin should be installed into:

~/.openclaw/extensions/infinity-native/

The Prompt to Give OpenClaw

Use this prompt:

Set up a native OpenClaw plugin integration for my Start Infinity account.

Reference the official Start Infinity docs first:
https://devdocs.startinfinity.com/2025-12-01.morava/

Requirements:
- Build this as a native OpenClaw plugin that normal agents can use directly.
- Use my Infinity Personal Access Token from an environment variable, not hardcoded in files.
- Use ~/.openclaw/.env as the token location if that is the most reliable runtime path.
- Use the required Infinity API headers:
- Authorization: Bearer <token>
- Accept: application/json
- Content-Type: application/json
- X-API-Version: 2025-12-01.morava
- Support pagination where relevant.
- Respect rate limits.
- Implement delete_item according to current Infinity behavior where delete archives the item.
- Keep inputs human-friendly and resolve names to ids where possible.
- Add basic error handling for missing token, malformed requests, lookup failures, rate limits, and API errors.

Initial tools to expose:
- infinity_get_profile
- infinity_list_workspaces
- infinity_list_boards
- infinity_get_board
- infinity_list_folders
- infinity_list_attributes
- infinity_get_attribute
- infinity_list_items
- infinity_get_item
- infinity_create_item
- infinity_update_item
- infinity_delete_item

Inspect my current OpenClaw config before changing anything.
After setup, verify the tool works through the normal agent path, not just shell commands.
Create short markdown docs in the plugin folder for technical reference and practical usage.
Clean up any failed prototype integration files after the native plugin is confirmed working.

What the Plugin Should Be Able to Do

At minimum, the finished integration should support:

Read

get profile
list workspaces
list boards
get board
list folders
list attributes
get attribute
list items
get item

Write

create item
update item
archive/delete item

What to Verify After Setup

Good Verification Flow

list workspaces
choose one real workspace from the results
list boards in that workspace
choose one real board from the results
list folders for that board
list attributes for that board
list items for that board
create a temporary test item if the board structure makes that safe
update the test item
archive the test item

Verification Prompts

Check That the Tools Exist and Work

Use the native Start Infinity tools through the normal OpenClaw agent path and verify that they are available.
Then list my Start Infinity workspaces.

Pick a Real Board from the Current Account

List my Start Infinity workspaces, then list boards in the workspace I choose next.
Do not assume any board names ahead of time.

Inspect a Real Board Structure

Use Infinity to inspect a real board from my account.
List its folders, list its attributes, and summarize what kind of data the board appears to track.

Verify Items

List items in a real board from my Infinity account and confirm that item reading is working.

Verify Create / Update / Archive

Using a safe test item in a real board from my Infinity account, create the item, update it, and then archive it.
Explain what happened at each step.

Important Implementation Notes

Use the official docs as source of truth.
The token should live in ~/.openclaw/.env.
The plugin should be enabled in ~/.openclaw/openclaw.json.
After code or config changes, restart OpenClaw.
Verify through the normal agent tool path, not only through shell-level API checks.
Keep the docs short and maintainable.

Common Mistakes to Avoid

stopping after a shell/API test without checking normal agent access
putting the token in the wrong place
hardcoding the token into source files
updating plugin source without refreshing the installed plugin
leaving failed prototype integration files around after the working version is done

Success Checklist