Infrastructure-as-code is the Wrong Abstraction defang.io/blog/post/infrastrā¦
1
205
Jordan Stephens retweeted
Deploying a Mastra app is a breeze with @DefangLabs
youtube.com/watch?v=2xzUIH1Dā¦
Jordan Stephens retweeted
the agents everyone is hyping right now wonāt survive the next platform update
not because theyāre bad
but because theyāre owned by someone elseās infrastructure
hereās the real shift:
current wave: agents fully dependent on closed platforms (OpenAI, Anthropic, GCP)
ā one policy change, one price hike, one rate limit⦠and your product dies
next wave: self-hosted operational intelligence. agents that run on your infra, learn your org, compound your advantage
nobody can take that away from you
hereās the difference:
CLOUD-DEPENDENT AGENT:
āplease let our agent run on your API, we promise we wonāt exceed rate limitsā
ā fragile, expensive, instantly commoditized
SELF-HOSTED AGENT:
āruns on your servers, learns your workflows, stores your context, gets smarter every weekā
ā becomes part of your infrastructure, not a feature
CLOUD-DEPENDENT AGENT:
āwhat if OpenAI changes the rules?ā
ā they will.
SELF-HOSTED AGENT:
āwhat if we owned the whole stack?ā
ā you do.
this matters commercially:
businesses pay $20/mo for an agent they rent
businesses pay $20K/mo for an agent they own
ownership compounds
dependency decays
if your agent dies when an API changes, youāre not building leverage ā youāre building risk
the future isnāt āyet another agentā
the future is sovereign AI infrastructure
agents that run locally, learn privately, and get better with time
most devs will keep shipping cloud-dependent toys
real operators are building self-hosted intelligence that nobody can shut down
defang makes this a one-command reality.
Jordan Stephens retweeted
When we started @DefangLabs we thought targeting Kubernetes made sense, but we quickly pulled the plug when we saw the unnecessary complexity and operational cost of such a solution. Now, Defang deploys to the native container orchestrator for each cloud.
Jordan Stephens retweeted
Replying to @merlinonthemoon
this whole thread is exactly why we built defang. doing all of this yourself works, but itās a lot of moving parts to maintain, and one silent failure still hurts.
with defang you get the same outcome without the manual setup. you write a small compose file, connect your cloud account, run:
defang compose up
and we spin up the full stack for you. health checks, auto restarts, logs, snapshots, alerts, uptime reports, container validation, infra drift checks ā all handled automatically in your own cloud.
no custom scripts, no watchdog agents, no ssh, no babysitting docker.
if you ever want to see how your setup would look on defang, happy to walk you through it.
Jordan Stephens retweeted
This is exactly why we built #Defang!
Define your app as a #Docker Compose project - which millions of devs already use for local deployments/testing.
Then literally with a single command ('defang compose up'), deploy that same Docker Compose project to #AWS... or #GCP, or #DigitalOcean, more coming!
#Defang takes care of networking, storage, databases, queues, even LLMs - all mapped to the native services on your target cloud - so ELB, ECS/EC2, RDS, Elasticache, Bedrock, etc. in the case of AWS.
Secure, Scalable, Cost-efficient - all done according to the best practices for the cloud you choose.
So, you get the ease of use of a Vercel, but all the power and economies of scale of a hyper-scalar.
Truly Develop Once, Deploy Anywhere!
theregister.com/2025/11/04/a⦠via @theregister
Jordan Stephens retweeted
Defang lets you do the exact same thing without the overhead of k8s. We turn docker compose files into cloud resources on AWS or GCP. Instead of `docker compose up`, you run `defang compose up` and get a scalable configuration in your own cloud account.
You finally did it. You dockerized your entire app.
Your Node API, your React frontend, your Postgres DB all neatly packaged. Your docker-compose file brings it all up perfectly on your machine. You feel like a genius.
Then comes production.
You need reliability. You need scale. So you think, "I'll just run my containers on a few servers."
Suddenly, the simplicity vanishes.
- How do your frontend containers find the API containers when their IPs keep changing?
- What happens when a server dies at 3 AM? Who restarts those containers?
- How do you update your API image without bringing everything down?
Manually scripting this across multiple machines turns into a nightmare, fast. Your beautiful Docker setup is now tangled in SSH scripts and hope.
You've heard of Kubernetes (K8s). Maybe you think it's just Docker Swarm but way more complex or something only huge companies need.
That's missing the core idea.
Kubernetes isn't just about running containers. It's about managing them automatically, at scale. It's an orchestrator.
The fundamental shift is this: You stop telling servers what to do (imperative). You tell Kubernetes what you want the end result to look like (declarative).
You define your application's desired state in YAML files:
- I want 3 replicas of my API container running image v1.2.
- They need to be reachable via a stable network name called api-service.
- They need 500MB of RAM each.
You give this to Kubernetes. Its entire job is to constantly watch the actual state and force it to match your desired state.
This is how it solves all those production nightmares:
Automatic Bin Packing & Scheduling:
- K8s looks at your servers (Nodes) and figures out the best place to run your containers based on available resources. You don't manually assign containers to machines.
Self-Healing:
- A container crashes. K8s notices. Actual state (2 replicas) doesn't match desired state (3 replicas).
- It automatically starts a new container to replace the failed one. No human intervention needed.
Horizontal Scaling:
- Traffic spikes. You need 10 API containers, not 3.
- You change one line in your YAML file (replicas: 10). K8s handles the rest, starting new containers across your available servers. You can even set it to autoscale based on CPU or memory usage.
Service Discovery and Load Balancing:
- How do containers find each other? You create a Kubernetes 'Service'.
- K8s gives this service a stable internal IP and DNS name (like api-service).
- When another container calls api-service, K8s automatically routes the traffic to one of the healthy API containers, balancing the load. No more hardcoded IPs.
Automated Rollouts (and Rollbacks):
- Need to update your API to v1.3? You update the image version in your YAML.
- K8s performs a rolling update by default: it gradually starts new v1.3 containers and stops old v1.2 containers, ensuring zero downtime.
- Update goes wrong? K8s can automatically roll back to the previous stable version.
Kubernetes isn't just running containers.
It's the automated, resilient operating system for your entire distributed application. It lets you manage complexity declaratively, so you can focus on your code, not on firefighting servers.
Jordan Stephens retweeted
āPredictive Processes and the Peculiar Case of Musicā - how might the predictive processing theory of brain function apply to music perception?
stefan-koelsch.de/papers/koeā¦
Math is _way more_ about relationships and perspective than it is about any "right answer." What a monumental tornado of everything wrong with math education and culture war politics in one shitty quote. nytimes.com/2022/04/18/us/flā¦
Jordan Stephens retweeted
The G7 summit should be followed by a C major summit to resolve everything.
Jordan Stephens retweeted
Sun June is the best band in TX and has been for a couple years now. Listen to their gorgeous new record
gorillavsbear.net/stream-newā¦
Jordan Stephens retweeted
Itās clear we have won the generational debate on progressive policies.
What isnāt clear is how we close the messaging gap on how to deliver and who the people trust to deliver it.
Thatās the task. Building trust with the people and a plan for the people.
take a minuteāor maybe 2:03š youtu.be/6jkze41gaB0
1






















