Olivia
Online
SYED RIAZ
@syedrz
Bangalore
Joined February 2010
494 Following
23 Followers
539 Posts
Someone turned Claude into an entire company.
42 skills, organised like a real org chart (links below):
Here is every department, and where to get each one.
Developers
Superpowers → https://t.co/pPPxKoPEwD
Context7 → https://t.co/3Kk9U8PG1T
Skill Creator → https://t.co/Lanao7tpOh
MCP Builder → https://t.co/Lanao7tpOh
Webapp Testing → https://t.co/Lanao7tpOh
Claude-Mem → https://t.co/yTb8qxqa7S
Designers
UI UX Pro Max → https://t.co/MQTtS9flwt
Taste → https://t.co/AEq4GZc60x
Frontend Design → https://t.co/AEq4GZc60x
Transitions → https://t.co/Z7JOt7lJb2
Web Artifacts → https://t.co/Lanao7tpOh
Brand Guidelines → https://t.co/Lanao7tpOh
Marketing
45 skills to run your marketing, from copywriting to SEO to lead magnets.
Access them all here → https://t.co/OWo258NM7L
Social Media
17 skills to run your social media, from post writing to Reels to thumbnails.
Access them all here → https://t.co/2qawCgAyQF
Finance
8 skills to run your finances, from statements to reconciliation to audits.
Access them all here → https://t.co/X6dVFcZBIJ
Small Business
31 skills to run your small business, from cash flow to payroll to invoicing.
Access them all here → https://t.co/7Prb2sXVpI
Legal
9 skills to handle your legal work, from contract review to NDAs to compliance.
Access them all here → https://t.co/GKaZzGYPOr
Every skill on the chart is real and installable from the links above.
Same departments. Same output. No payroll.
Bookmark this.
the four types of agent loops.
loop engineering keeps getting talked about as one thing. it's actually a choice between four structures, and each one fits a different kind of task.
it means designing the system that steers the agent, instead of steering it yourself move by move.
that system always answers two questions. what starts a run, and what decides the work is done.
in a hand-run session you answer both yourself, every single time. each loop type moves more of that into the system.
here's each type, what triggers it, and when to reach for it.
1) turn-based.
triggered by a user prompt. the agent gathers context, acts, and checks its work inside a single turn, then a human reviews the output and writes the next prompt.
use this when requirements are still forming and every output changes what you'd ask for next.
2) goal-based.
triggered by a /goal command carrying success criteria and a budget, like "get the homepage Lighthouse score to 90, stop after 5 tries." when the agent tries to stop, an evaluator model checks whether the goal is met, and a no sends it back to work.
use this when the outcome is measurable but the path there isn't worth your attention.
3) time-based.
triggered by a clock. an interval fires, the agent runs a fixed prompt like "check the PR, fix CI," then waits for the next tick. /loop runs on your machine, /schedule moves it to the cloud so it survives a closed laptop.
use this for recurring work where the task is known in advance and only the timing repeats.
4) proactive.
triggered by an event or schedule with no human present. a routine watches a channel, and when something needs handling it spawns a workflow with a triage agent, a fix agent, and a reviewer that adversarially judges the work before the task closes.
use this for standing responsibilities where you can't predict what will come in, only that something will.
each type hands off one more job than the last. turn-based keeps both with the human, goal-based automates the checking, time-based automates the trigger, and proactive automates both while deciding the workflow shape at runtime.
so the mapping question isn't which loop is most advanced. it's whether your task is exploratory, measurable, recurring, or standing.
the more you hand off, the less you babysit.
I wrote the full breakdown on loop engineering. the article is quoted below.
I turned Claude into an entire company.
42 skills, organised like a real org chart (links below):
Here is every department, and where to get each one.
Developers
Superpowers
→https://t.co/tGNwFVYsEa
Context7
→ https://t.co/oExBVynS4S
Skill Creator
→ https://t.co/iR9fyxUFvL
MCP Builder
→ https://t.co/iR9fyxUFvL
Webapp Testing
→ https://t.co/iR9fyxUFvL
Claude-Mem
→ https://t.co/emHpdPtiUO
Designers
UI UX Pro Max
→ https://t.co/54NvwKmBix
Taste
→https://t.co/gFud3Sa93j
Frontend Design
→ https://t.co/gFud3Sa93j
Transitions
→ https://t.co/kZP238n3Zy
Web Artifacts
→https://t.co/iR9fyxUFvL
Brand Guidelines
→ https://t.co/iR9fyxUFvL
Marketing
45 skills to run your marketing, from copywriting to SEO to lead magnets.
Access them all here
→ https://t.co/oBsac9TKK4
Social Media
17 skills to run your social media, from post writing to Reels to thumbnails.
Access them all here
→ https://t.co/ZwNtoUTdVm
Finance
8 skills to run your finances, from statements to reconciliation to audits.
Access them all here
→ https://t.co/qk0ioMAxim
Small Business
31 skills to run your small business, from cash flow to payroll to invoicing.
Access them all here
→ https://t.co/m9kHptmfv9
Legal
9 skills to handle your legal work, from contract review to NDAs to compliance.
Access them all here
→https://t.co/ucxqTYH4v9
Every skill on the chart is real and installable from the links above.
Repost ♻️ this to help your network build their own.
Ex google engineer acaba de soltar un curso completo de 1 hora para construir agentes de IA que se mejoran solos, desde cero:
00:00 – Cómo nace un agente que se construye a sí mismo
03:01 – soul.md: el archivo que lo controla todo
30:16 – RAG inteligente: solo traes 20 mensajes relevantes, no los 2.000
31:48 – El loop que sabe cuándo parar solo
35:14 – Detectar el error y arreglar el prompt en el momento
50:22 – Cómo Claude comprime y optimiza tu memoria automáticamente
1 hora de contenido práctico que vale más que la mayoría de cursos de pago sobre agentes.
Míralo completo, guárdalo📚
China has killed the entire vector database industry.
They open-sourced TencentDB Agent Memory. It gives any AI agent long-term memory that runs 100% locally.
No Pinecone. No cloud APIs. No repeating yourself every session.
- 61% fewer tokens
- PersonaMem accuracy: 48% → 76%
- Zero external API dependencies
- Runs on plain SQLite
Most memory systems compress your history into an opaque vector pile. when recall goes wrong, you're guessing. this one doesn't compress, it builds a semantic pyramid.
L0 Conversation → L1 Atom → L2 Scenario → L3 Persona.
Short-term state gets encoded as a Mermaid graph in your agent's context. verbose tool logs get offloaded to disk. when the agent needs proof, it drills back via node_id to the exact raw log.
no lossy compression. every layer is readable markdown you can just open and inspect.
5.1k stars. 100% Open Source.
https://t.co/YA9AvlYHOA
Your AI agent skills don’t need to live in scattered prompt files.
OPC Skills is a public GitHub repo of reusable agent skills for solopreneurs, indie hackers, and one-person companies.
It helps you extend tools like Claude Code, Cursor, Codex, and Windsurf by packaging specialized instructions, scripts, and resources into self-contained skill folders your agent can load when needed.
Key features:
• Self-contained skill format – each skill lives in its own folder with a SKILL.md file for instructions and metadata
• Ready-made skill set – includes skills for SEO/GEO, user-demand research, domain hunting, logo creation, banners, Reddit, X, and more
• Claude Code marketplace support – install skills directly through the OPC Skills plugin marketplace
• Universal installer – npx skills add supports Claude Code, Cursor, Windsurf, Codex, and other AI coding tools
• Contributor-friendly structure – the README shows how to create a new skill folder and submit it by PR
It’s open-source under the Apache License 2.0.
Link in the reply 👇
Stanford researchers did it again.
They just built the agent-native version of Git.
When an agent works on a longer task, the run builds up a lot of state.
This includes files edited/created, a dev server, a database, installed packages, KV cache, etc.
Say the agent is at step 10 and makes a mistake, maybe it misreads a traceback and rewrites a file that was actually fine.
The tests start failing, and the run goes off track, although everything through step eight was correct.
By default, the agent just tries to fix it, which creates more edits and tool calls. This burns more tokens and grows the context.
The other options are a person stepping in to redirect it or restarting the whole run from step one.
That's wasteful, because it pays for every model/tool call again and re-prefills the context. Moreover, since an agent's run is non-deterministic, it doesn't reproduce the same early steps anyway.
The reason it's hard to just jump back exactly to a previous correct step and resume from there is that the trajectory is only a message log.
It records what the agent said and which tools it called, but not the live state underneath.
That state includes things like memory, open file handles, child processes, installed packages, /tmp, and KV cache. None of that is in the log.
Git can version the files, but it doesn't snapshot the running process or the KV cache. Checking out step eight moves the files back, but the process is still sitting in step-ten memory with a cold cache.
Shepherd is a runtime layer by Stanford that records the run as a trace of typed events rather than a flat log.
Each agent-environment interaction becomes a commit, similar to Git, but it tracks the live run.
Its commit includes the agent process and the filesystem together, copy-on-write, so a branch carries the actual state and not just the files.
Going back to a previous step is then a single call that forks from that commit and continues from the exact state.
The copy-on-write fork is roughly five times faster than docker commit, and because the prompt prefix through step eight is unchanged, the KV cache is reused over 95% on replay, so early steps aren't reprocessed again.
Once the run can be forked, a meta-agent can sit on top and operate it. It watches the trace and reverts as soon as it looks wrong, before the bad write is committed.
In practice, it's just Python calling fork, replay, and revert on the trace, rather than a separate control plane wired into the harness.
Not everything is reversible though.
Files and sandbox changes undo themselves, but a database write has no automatic undo, so it needs a matching undo step set up in advance.
Something external, like a sent email or a real charge, can't be undone, so the supervisor's job there is to catch it before it fires.
They tested this on a few public benchmarks. On CooperBench, where two agents work on the same codebase, adding a live supervisor took the pair-coding pass rate from 28.8% to 54.7%.
It's still early and labeled alpha. The benefit mostly shows up when a run gets branched a lot over a heavy sandbox state, which is exactly where restarting wastes the most tokens and time.
If Git was made to make file changes reversible, Shepherd is trying to do the same thing for a live agent run.
Shepherd Repo: https://t.co/5e8W5oxY6F
(don't forget to star it ⭐ )
That said, Shepherd reverts a bad step inside a run. The harness around it, the prompts, tools, and checks the supervisor relies on, still drifts across runs as models and dependencies change.
Akshay wrote about making that harness repair itself, where a failing trace gets diagnosed, the fix is verified against the exact input that failed, and the failure is locked as a regression test so it can't recur.
Read it below.
How to build a 1-person AI company that:
- Runs locally
- 100% open-source
- No human employees, all agents
- Real-time collaboration via email
Multi-agent orchestration is not new. Plenty of frameworks already let agents hand off tasks, run in parallel, and talk to each other.
So the interesting question is not whether agents can collaborate. It is what structure you use to make them collaborate.
The common approach is to wire a graph of nodes and edges and reason about the plumbing yourself. It works, but you are learning a new abstraction just to describe who does what.
There is a coordination structure we have trusted for a hundred years already: an organization.
Every company runs the same way. People have roles, roles have reporting lines, and work moves up and down that chart without anyone relaying each message by hand.
Map that onto agents and the whole thing gets intuitive. You lay out an org chart, each agent fills one role, you talk to the person at the top, and the org sorts out the work between them.
You already know how a company works, so you already know how to run one here. There is no new abstraction to learn.
That is exactly what Alook does. Each agent is a live Claude Code or OpenCode session with a defined role, a reporting line, and its own email inbox.
The agents coordinate over email, the same way a team would. And it all runs locally through a runtime on your own machine, so nothing leaves your setup.
You bring your own agent too. Claude Code and Codex both work, and if you would rather stay fully open source and local, OpenCode works the same way.
To show how this feels in practice, I set up three agents as a small sales team.
Vi is the one I talk to. I hand Vi a goal, and Vi routes the work down the chart.
Neile runs prospect research. Vi passes the target criteria, and Neile reports back a ranked list of names, roles, and companies, each with a suggested angle and a confidence score.
Lliane runs outreach. Vi hands over the messaging angle and follow-up cadence, and Lliane reports back on emails sent, responses received, and any deal that needs escalation.
I never relay a message between them. Neile and Lliane report to Vi, and Vi updates me in one place.
The whole thing is open source and self-hosted, so it runs on your machine with your own agents. Give the repo a star if you want to follow where it goes: https://t.co/vpAb0dy7AD
I also wrote a full walkthrough on building your own AI company with it, from a blank org chart to a running job. The article is quoted below.
Cheers! :)
Anthropic engineer:
"You're not supposed to prompt Claude. You're supposed to build a system that prompts itself."
In 45 minutes she shows exactly how to build an agent that improves itself.
Most people are still doing all of this by hand.
Watch the session, then save the guide below.
ANTHROPIC LEAD ENGINEER MAKING $2.3M/YEAR JUST LEAKED A 12-PAGE DOCUMENT - AND GOT FIRED 15 MINUTES AFTER PUBLISHING
most developers build loops - but almost every loop breaks in one of five ways, and each failure has a symptom visible from the outside without reading a single line of code
> Blind loop - the agent waits for a human to hand it work every morning - automating execution but not discovery
> Tangled loop - parallel agents share one directory and overwrite each other parallelism that destroys instead of multiplies
> Nodding loop - the agent grades its own work and approves it every time a loop that has never said no to itself is broken
> Amnesiac loop - results live only in the context window every morning the system wakes up with no memory of yesterday
> Manual loop - no trigger a human presses the button to start it that is not a loop that is a script waiting for a person
a real loop finds its own work - remembers what it did has something that can say no never lets two agents touch the same file and fires itself on a timer
remove any one of the five - and the loop either breaks or never starts
12 pages that changed how I build agentic systems today
Again and again... your agent's reliability lives in the harness, not the model.
Based on 603-page survey paper "The Hitchhiker's Guide to Agentic AI"
The harness is the code (OS) that runs the loop. Swap in a smarter model and a missing one still fails the same way.
It does four unglamorous things:
> calls the model each turn
> dispatches tools and tracks state
> retries when a step fails
> logs every action for you
Without it, one bad tool call stalls the whole run in silence. You find out when the pull request never shows up.
With it, the agent recovers from a failed step instead of freezing. And you can see exactly what it did, and undo it.
That's what separates a demo from something you trust in production.
Don't hand-roll this. Reach for LangGraph or the OpenAI Agents SDK.
Spend your time on the task, not the plumbing.
The article below walks the full stack:
> retrieval and memory systems
> the harness and orchestration
> tools, MCP, and A2A
> multi-agent coordination and evaluation
I used to think ingesting 1,000,000 documents into an AI memory system was mostly a compute problem. But I've been proven wrong...
This is an orchestration problem.
Throwing more GPUs at the pipeline won't help much if your architecture still processes everything sequentially.
The system I've been designing separates ingestion into two independent work pools.
The first turns raw data into documents.
The second turns those documents into memory.
Here's the high-level architecture:
1/ Two levels of paralleism
Imagine ingesting 1,000,000 documents.
A @PrefectIO workflow shards them into 1,000-document jobs.
Each worker then processes those jobs in batches of 100.
That gives you two levels of parallelism:
1. Pipeline parallelism → distribute shards across workers.
2. Task parallelism → batch expensive operations inside each worker.
Need more throughput for LLMs or embeddings?
Swap in a Dask or Ray cluster without changing the architecture.
2/ Data work pool
The pipeline starts with:
Web URLs
RSS feeds
A @PrefectIO workflow flattens every source into URLs, shards them into jobs, and pushes them into a queue.
Workers continuously pull jobs as capacity becomes available, making it easy to absorb traffic spikes by simply adding more workers.
Each worker:
Flattens URLs
Scrapes 100 URLs concurrently
Transforms content
Batch-loads documents into storage
This stage is mostly network and database I/O.
Batching matters far more than compute.
3/ Memory work pool
Once documents reach the warehouse, a second @PrefectIO workflow repeats the pattern.
Each worker runs:
Chunking
Batched LLM extraction
Entity normalization
Batched embeddings
Knowledge graph generation
For example, 1,000 documents might become 10,000 chunks, processed in batches of 100.
Every stage has different bottlenecks.
LLM extraction → vLLM
Entity normalization → database I/O
Embeddings → often CPU
Treating them all the same leaves performance on the table.
Here's the gist:
Scaling AI memory isn't about adding GPUs.
It's about designing an architecture where every bottleneck scales independently.
This is why I chose @PrefectIO.
It orchestrates both pipelines with sharding, queues, retries, scheduling, and durable execution, making it practical to scale from thousands to millions of documents.
P.S. What would stop your pipeline from ingesting one million documents today?
Agent Caching Strategies for Performance and Cost Optimization
Agents often repeat similar requests, which wastes tokens and increases cost.
Caching helps store and reuse previous results intelligently, improving speed and reducing expenses.
This is becoming essential as agent usage grows and token costs add up.
As a dev, I now implement smart caching in most production agent systems.
Agent Caching Cheatsheet:
Use prompt caching for repeated system instructions
Apply semantic caching for similar user queries
Cache tool responses when data doesn’t change often
Set proper TTL (time-to-live) for cached results
Combine caching with context compression
Pro tip: Start with prompt caching and semantic caching for quick wins
How are you optimizing cost and performance in your agents? Reply below 👇
Follow @AiCamila_ for daily production AI + DevOps tips.
#AgentCaching #CostOptimization #ProductionAI #AgenticAI #TokenSavings
MCP and Claude won't solve your company's knowledge problem.
In fact, they'll probably make it worse.
The demo is a bit seductive. Connect a model to a few tools, point it at some docs, ask a question, and you're done.
It feels like the stack is enough.
IMHO, that framing misses what teams actually struggle with. A company brain is not just access.
It's context, trust, and structure. Without that, you don't have shared knowledge. You have a smart interface sitting on top of chaos.
MCP + Claude can be a powerful layer. But the layer is not the system.
→ 𝗔𝗰𝗰𝗲𝘀𝘀 𝗼𝘃𝗲𝗿 𝗔𝗹𝗶𝗴𝗻𝗺𝗲𝗻𝘁
If every source says something slightly different, the model will still answer. That does not mean the answer is grounded in a team-approved reality. A company brain needs one place where knowledge gets shaped, clarified, and maintained.
→ 𝗥𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗼𝘃𝗲𝗿 𝗥𝗲𝗹𝗶𝗮𝗯𝗶𝗹𝗶𝘁𝘆
Pulling information is easy. Knowing whether it is current, duplicated, or safe to act on is the hard part. Teams do not just need responses, they need confidence.
→ 𝗧𝗼𝗼𝗹𝗶𝗻𝗴 𝗼𝘃𝗲𝗿 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄
People assume knowledge work starts with a prompt. Usually it starts with onboarding, handoffs, decisions, and repeat questions. A company brain lives inside those moments, not just inside chat.
We should absolutely use MCP. We should absolutely use Claude. I love that direction.
But if we skip governance, curation, and usability, we are building a very fast way to surface messy information.
We’re currently writing an ebook on how teams build trust and structure in their knowledge bases.
I'm curious: is your team trying to assemble a company brain from model + connectors alone?
If you are, I'd would love to hear what is working, and where it breaks - it would help me a ton if you can fill in this 4-min survey or we'll have a coffee chat about it 🤗
Share your experience here: https://t.co/pbv7bEEZVV
ANTHROPIC JUST LEAKED AN INTERNAL DOCUMENT WORTH $2.6M - IT CHANGES HOW YOU SHOULD BUILD AI SYSTEMS
most AI systems fail not because the model is weak - but because it lacks the right information at the right moment
Search → Compress → Memory → Routing → Verification
five layers, one system, always has the right context
first generation engineers picked better models - second wrote better prompts - third builds better infrastructure around the model
context became the operating system - not the input
better context reduces hallucinations, cuts latency and improves task execution quality - strong context systems outperform larger models in real scenarios
the systems that win won't have the largest context windows - they will have the highest quality context
Context Engineering is not a feature - it's the foundation
Alibaba engineer who leads Qwen explained the future of open agent models in 25 minutes - better than $2000 LLM training courses.
pre-train the base ->SFT -> RLHF -> tool use -> multi-modal -> ship a whole family (chat / VL / coder / math / QwQ).
That loop is why Qwen quietly became the most downloaded open model family on Hugging Face.
Qwen base + Qwen-VL + Qwen-Coder + QwQ reasoning - that's the stack.
Watch and save it, then read the article below.
Andrej Karpathy quietly shipped the best second brain idea in years
not an app. a pattern. let an llm maintain a wiki of your notes.
you dump sources, it reads them, links them, files them. knowledge compounds like interest.
someone built it into a free claude code plugin.
setup is two commands:
claude plugin marketplace add AgriciDaniel/claude-obsidian
claude plugin install claude-obsidian@agricidaniel-claude-obsidian
then open obsidian, open claude code in the same folder, type /wiki.
that's it. your notes are now queryable by claude and
they get richer every time you read something.
bookmark this. best thing you'll build this weekend.
ANTHROPIC JUST LEAKED AN INTERNAL ENGINEERING DOCUMENT - AND IT SAVES SOLO DEVELOPERS $300,000 A YEAR
the highest-leverage AI systems are no longer prompt-driven - they are loop-driven - and that one shift changes everything
Generate → Evaluate → Remember → Schedule → Optimize → Recurse
six layers, one loop, improves itself without a human
Generation: the system produces its own solutions - no human writes the brief
Evaluation: a second layer measures quality - the thing that can say no
Memory: every execution retains useful discoveries - the loop gets smarter each cycle
Scheduling: the system decides what happens next - nobody manages the queue
Optimization: behavior updates based on what worked - static prompts eventually hit diminishing returns
Recursion: remove any single layer - and system performance drops significantly
the role of the human shifts from operator to architect - and AI transforms from a prediction engine into an adaptive production system
the future of AI engineering is recursive
🚨ANTHROPIC ACABA DE PUBLICAR EL MANUAL PARA MONTAR UNA EMPRESA SIN EMPLEADOS
>CEO: 1 persona.
>empleados: agentes de claude
dura 30 minutos y es gratis
Guarda esto en favoritos para que no lo pierdas.
Last Seen Users on Sotwe
Most Popular Users
Elon Musk 
@elonmusk
241M followers
Barack Obama
@barackobama
119.2M followers
Donald J. Trump
@realdonaldtrump
111.8M followers
Cristiano Ronaldo
@cristiano
111.8M followers
Narendra Modi
@narendramodi
107M followers
Rihanna
@rihanna
98M followers
NASA
@nasa
92.2M followers
Justin Bieber
@justinbieber
91.2M followers
KATY PERRY
@katyperry
88.3M followers
Taylor Swift
@taylorswift13
82.2M followers
Lady Gaga
@ladygaga
73.7M followers
Virat Kohli
@imvkohli
70.9M followers
Kim Kardashian
@kimkardashian
70.1M followers
YouTube
@youtube
68.7M followers
Bill Gates
@billgates
64.2M followers
Neymar Jr
@neymarjr
63.8M followers
The Ellen Show
@theellenshow
62.4M followers
CNN
@cnn
61.8M followers
Selena Gomez
@selenagomez
61.4M followers
X
@x
60.8M followers