AI coding is constantly evolving. Whether you use Claude code or cursor, it doesn't matter.

People are realizing that simply giving a large prompt to your AI coder is not

enough anymore. This realization led to the introduction of context engineering a while back. Now,

I had problems with this approach as well. Context engineering is basically the art of

filling the context window of the model with only the stuff that it needs to

know for a specific task. Sounds good in theory, right? But here's the issue. You

never follow a set path when coding. You encounter errors, you might need to implement

something new or you discover you need additional context midway through. When that happens, you're

stuck. You need to constantly update your context. What you really need is your own

knowledge base and not just any knowledge base but one through which the AI agent

can get the accurate data it wants as fast as possible. This is where this

new agent system, Archon, comes in. Let me give you a clear overview of Archon

and then explain how it solves one of the biggest problems in AI coding. Let's

start with the project I have two projects here, a test project and a task

class project. Each project contains two essential tabs, docs and tasks. This is your complete

context management system. Your documentation lives here, giving your AI agent full knowledge of your

project. When I open this, you'll notice they've added templates. This means when your AI

agent connects, whether it's Claude or Cursor, it doesn't create random documentation. It follows these

templates, like architecture documentation or feature PRDs, keeping everything properly organized. The

tasks tab works beautifully with your documentation. Based on your project scope, meaning what you

want to build, the backlog automatically populates with relevant tasks. The AI agent manages

tasks independently and maintains task memory. It never loses context and always knows which

tasks need completion. You can create unlimited projects and manage them efficiently. In my task

class project, for instance, one task sits in the backlog while 13 are actively in

progress. Next is the MCP server, which connects Archon to your AI agents. Setup is

remarkably simple. They have setup commands for all agents, like Claude Code, whose command is

really hard to search up. This is especially valuable for users uncomfortable with code editors

or terminals. Now here's the feature that makes Archon exceptional, the knowledge base. The knowledge

base accepts any documentation you need. You can add links to any tools documentation. For

example, I imported the entire SwiftUI documentation from Apple's developer site. That's

505 pages containing over 126,000 words. In the add knowledge base

section, you'll find categories of knowledge. You can add URLs or hosted documentation sites. The

application

What

makes this different from other tools? Archon implements a complete RAG system. When you install

it, you're setting up a proper database for RAG instead of simple text search. The

system stores data and applies semantic search. The result is fast, accurate, and personalized retrieval.

Here's a practical example. In my test project's docs section, I I can add project-specific

sources. Say I'm building a Swift app and Liquid Glass UI just released. LLMs don't

know about it yet. The solution is feeding ARK on the Swift UI documentation. I

added the docs to the knowledge base, set the crawl depth to 2, which is

optimal, and let the crawler process everything. The crawler works programmatically. It follows every link

on the site, navigates through menus, enters each page, and extracts all information systematically. This

is a comprehensive system combining context engineering, RAG, web script,

That's the

beauty of this community. Now, a quick break to

tell you about today's sponsor, Logs.so. Ever launch a feature and have no clue if

anyone touched it? Or find out about a payment failure only when a customer tweets

at you? Logs.so shows every sign-up, click, payment, and error in one live feed. No

dashboards, no dev console, just a simple timeline anyone on the team can read. You

don't have to wire up fancy tools or write code. Paste one line into your

site or drop the snippet into whatever builder you're using and watch events roll in.

The first 1,000 events every month month are free forever. That's enough to track a

side project or prove value before you even pay a cent. Ready to see what

really happens in your product? Hit the link below and start tracking with logs.so. This

is the GitHub repository of Archon and the first thing you're going to do is

come here and copy the link. Then you'll go back into your terminal. You're going

to clone the GitHub repository and add it inside your chosen directory. You can see

that for me it already exists and I already have it up and running successfully.

When I ran it you can see it completed successfully. After the GitHub repository is

installed, you're going to run this specific command that's shown right here in the GitHub

repository. This command will create your .env file, where you need to put some important

variables that I'll show you in just a moment. Now, since Archon is a proper

knowledge hub, it needs a proper database to perform RAG and all the AI searching

capabilities that it provides. For this, the author has chosen to use Supabase as the

main database, and setting it up is really simple. First, make sure you have a

project created in Superbase. As you can see, I created a project called Archon. The

great thing is, you don't need to pay for this. The free version of Superbase

is absolutely enough for what we need. Next, you need to create your database tables

inside Superbase. But don't worry about having to do that manually. They've provided an automatically

configured setup that makes this incredibly easy. All you have to do is open the

current repository inside cursor so you can easily access all the files. Just use this

command. It'll open the Archon repository directly inside cursor. Once you're inside cursor, navigate to

the migration folder. There you'll see a complete setup.sql file with everything configured. Simply

copy the whole thing and go back into Superbase. In the Superbase sidebar, you'll find

the SQL editor. You can see that I've already pasted mine, but basically you paste

the SQL code there and run it. Once it finishes executing, you'll see the message,

success and no ruse returned. That confirmation means the database has been set up correctly.

Now once you're done with that setup, you need to grab two important credentials. Head

into the settings section of Superbase and first go to the data API section. Here,

you'll get your project URL. Copy that. Then navigate to API keys. Reveal the service

role API key and copy that as well. Go back to your .env file. Remember

the .env is a copy of the .env.example file which you created earlier using the

cp command. Here you'll paste your Superbase URL that you just copied and then paste

your service role key in the appropriate field. Once you've done that, you'll run the

Docker Compose Up command. The first time you run this command, it will take some

time as it needs to fetch and build all the Docker containers. For this to

work, you do need to have Docker running. So make sure Docker is turned on

and running in the background on your system, whether you're on Windows or Mac, before

executing this command. Docker will go ahead and start all the containers and you'll see

a progress bar showing the setup progress. Once it finishes, you'll see that four containers

have been started. Archon Agents, Archon Server, Archon MCP and the front end. Finally, if

you go to the Archon UI, which is now running, you'll find it at localhost

3737. Just enter that address in your browser and it will automatically take you through

the first step, the onboarding step that gets everything configured for your use. After you've

set everything up and your services are running, when you open the front end link

in your browser, you're going to be greeted with this onboarding flow. The first thing

you'll need is an additional API key. You can go ahead and choose between Google

Gemini or OpenAI for this. In their documentation, they've specifically listed Google Gemini and its

free models as a good alternative. They mentioned that the free rate limited models are

completely sufficient for this use case and you won't exceed the limits during normal operation.

I'm just going to go ahead with OpenAI. The reason you need to provide another

API key is for the RAG implementation. To make RAG work, the system needs to

convert the words in your documents into numbers based on their meaning. This conversion process

is what makes the search so fast and accurate and it requires a

Let me take you through the actual process that needs to be done. First, you

create a new project, like I did. After creating the project, I went into Claude

Code and asked it to search for all the projects. It fetched my project and

returned the ID along with the description. In that description, I had defined that it

should only use local storage, follow a specific architecture, and be built with SwiftUI. Next,

I told it that I wanted to build the app and provided some requirements. I

specified that it must use liquid glass and that I just wanted two pages in

the app for now. Think of this step as writing a PRD and you can

discuss this with cloud code and finalize this. You just need to focus on the

features you want. Archon can just then create the docs using the templates that I

showed you. Think of your coding agent as the tool that's only there to execute

tasks while Archon is the context box where all your knowledge and instructions live. Going

back to the process, once the documentation was ready and it had the SwiftUI knowledge

base in it, it needed to create tasks. I told it to break the work

into two cycles of tasks for simplicity. It went ahead and started generating tasks. If

you check the tasks tab, you'll see that there are tasks placed in the backlog

and the ones that done are awaiting review. Then I told it that the iOS

app I made in Xcode was already set up. and it just needed to begin

development. Using the Manage Tasks tool, Archon's MCP began executing the tasks. Now, you might

wonder how it knows when to use the documentation. Before, as you know, the big

issue was that giving some context for a single task, and many times that context

wouldn't turn out to be enough. With Archon, this problem is completely solved. The coding

agent is integrated with Archon, so that whenever it feels even the slightest uncertainty, it

automatically fetches the required documentation. Before creating tasks or PRDs, it already uses

RAG to gather context, but throughout the entire process, it keeps fetching more documentation if

needed. This way, it never relies on an inaccurate web search or the limited context

for the task. And how is this behavior built in? Well, Archon provides a rules

file. This file essentially tells the agent how to function with the Archon MCP connector.

You can get this file directly from the settings, copy the rules, and apply them

to any agent. There is one specifically for Claude Code, but the universal one can

also So

moving

on, I completed the first cycle and then I ran into a small error in

the app which is normal with Swift. It created the error as another task and

fixed it as well. I also gave it some additional instructions and it added those

as tasks as well. For example, here it needed to implement the glassmorphism effect during

the second cycle in the Polish phase. Now here, since it wasn't certain, it performed

its RAG query to search for results. It didn't find much in that, so pulled

the code examples and found some helpful implementation in that. So again, it automatically knows

when it needs to perform a RAG search whenever it's uncertain about something or doesn't

have the information. After that, it went ahead, coded everything, and completed the tasks. Now,

in a way, this is similar to what you've already seen in other framework systems

with task management, like for example, the BMAD method. In my opinion, the BMAD method

offers a better flow for coding using the agile method and there is a set

path but until that happens in this tool it's not really that beginner friendly and

you might need to experiment to find the perfect flow with this. But the amazing

thing Archon gives you is its knowledge base and that's what I'm encouraging you to

take advantage of. I'm sure that looking at this people will definitely start building more

tools on top of it and that's why I'm really excited about it. Moving into

xcode in the simulator you'll see that I had also requested a widget. The code

for the widget was completed but I had to manually add it into the app.

It can't be done automatically with a command, so I still had to do a

bit of manual work, which is why the widget isn't showing here. Other than that,

the basic app that I wanted to make was ready and I could use it.

Another thing I want you to know is that Archon is currently in its beta

version. This is the beta release and soon enough they're going to be launching the

final version. It's already scheduled, so keep an eye out for that. If there are

any major improvements in the workflow or how it's used, I'll definitely make another video

to keep you updated. That brings us to the end of this video. If you'd

like to support the channel and help us keep making videos like this, you can

do so by using the super thanks button below. As always, thank you for watching

and I'll see you in the next one.